{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# No.1 导入arcpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关键技术点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1、所有的包在Python同一次运行中，里面仅第一次需要导入，第二次在输入import的时候，是不会重复执行导入过程的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 2、arcpy包非常庞大，所以在外部导入需要比较长的时候，可以在脚本进程启动的时候就做一次导入。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 3、可以用datetime来监控导入arcpy需要的时间，以做好效率开销的预算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 4、在jupyter notebook 里面，可以用%%time魔术方法，来监控运行时间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 5、不要用%%timeit 来做，原因参考第一条（%%timeit表示重复测试若干次，取平均值）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 以下代码执行的时候，每个单元都请重启整个notebook，否则出不来效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import arcpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "s = datetime.datetime.now()\n",
    "import arcpy\n",
    "print(datetime.datetime.now() - s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 16.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "import arcpy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 独立导入arcpy包下面的模块，可以显著提高效率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 5.27 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "import arcpy.da as da"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# No.2 如何获取ArcPy中的帮助"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关键技术点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ArcPy 具备完善的帮助文档，有两种获取渠道\n",
    "  * 1. 随产品一并安装的帮助文档\n",
    "  * 2. 在线官方资源站点\n",
    "  * 3. Python自带的help函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on package arcpy:\n",
      "\n",
      "NAME\n",
      "    arcpy\n",
      "\n",
      "DESCRIPTION\n",
      "    # -*- coding: utf-8 -*-\n",
      "    #COPYRIGHT 2018 ESRI\n",
      "    #\n",
      "    #TRADE SECRETS: ESRI PROPRIETARY AND CONFIDENTIAL\n",
      "    #Unpublished material - all rights reserved under the\n",
      "    #Copyright Laws of the United States.\n",
      "    #\n",
      "    #For additional information, contact:\n",
      "    #Environmental Systems Research Institute, Inc.\n",
      "    #Attn: Contracts Dept\n",
      "    #380 New York Street\n",
      "    #Redlands, California, USA 92373\n",
      "    #\n",
      "    #email: contracts@esri.com\n",
      "\n",
      "PACKAGE CONTENTS\n",
      "    _ba\n",
      "    _base\n",
      "    _colorizer\n",
      "    _ga\n",
      "    _geocoding\n",
      "    _mp\n",
      "    _na (package)\n",
      "    _renderer\n",
      "    _symbology\n",
      "    _tool_wrapper\n",
      "    _utbx\n",
      "    _wmx\n",
      "    agolservices\n",
      "    analysis\n",
      "    arcobjects (package)\n",
      "    aviation\n",
      "    ba\n",
      "    ca\n",
      "    cartography\n",
      "    charts\n",
      "    cim (package)\n",
      "    cmanagers (package)\n",
      "    conversion\n",
      "    da\n",
      "    ddd\n",
      "    defense\n",
      "    edit\n",
      "    fmefunctionfactory\n",
      "    ga\n",
      "    gapro\n",
      "    geoanalytics\n",
      "    geocoding\n",
      "    geoprocessing (package)\n",
      "    ia (package)\n",
      "    indoorpositioning\n",
      "    indoors\n",
      "    intelligence\n",
      "    interop\n",
      "    locref\n",
      "    lr\n",
      "    management\n",
      "    maritime\n",
      "    md\n",
      "    metadata\n",
      "    mp\n",
      "    na\n",
      "    nax\n",
      "    nd\n",
      "    parcel\n",
      "    pdfdocument\n",
      "    ra\n",
      "    reviewer\n",
      "    sa (package)\n",
      "    server\n",
      "    sfa\n",
      "    sharing\n",
      "    stats\n",
      "    stpm\n",
      "    td\n",
      "    time\n",
      "    tn\n",
      "    toolbox\n",
      "    toolbox_code\n",
      "    toolbox_linux\n",
      "    topographic\n",
      "    transit\n",
      "    un\n",
      "    utils\n",
      "    wmx\n",
      "\n",
      "SUBMODULES\n",
      "    arcobjectconversion\n",
      "    geometries\n",
      "    mixins\n",
      "\n",
      "FUNCTIONS\n",
      "    AcceptConnections(sde_workspace, accept_connections)\n",
      "        AcceptConnections(sde_workspace, accept_connections)\n",
      "        \n",
      "        Allows an administrator to enable or disable the ability of\n",
      "        nonadministrative users to make connections to an enterprise geodatabase.\n",
      "        \n",
      "          sde_workspace(String):\n",
      "        The Enterprise geodatabase that will have its connection property\n",
      "        altered.\n",
      "        \n",
      "        The connection properties specified in the Enterprise Geodatabase must be\n",
      "        the geodatabase administrator.\n",
      "        \n",
      "          accept_connections(Boolean):\n",
      "        Boolean value indicating if the geodatabase will accept connections\n",
      "        (True) or will not accept connections (False).\n",
      "    \n",
      "    AddDataStoreItem(connection_file, datastore_type, connection_name, server_path, client_path='', hostname='')\n",
      "        AddDataStoreItem(connection_file, datastore_type, connection_name,\n",
      "        server_path, {client_path}, {hostname})\n",
      "        \n",
      "        Registers a folder or database with an ArcGIS Server site.\n",
      "        \n",
      "          connection_file(String):\n",
      "        An ArcGIS Server connection file (.ags) representing the server with\n",
      "        which you want to register the data.\n",
      "        If you've made a connection in ArcCatalog you can use the connection file\n",
      "        found in your user profile directory.\n",
      "        \n",
      "          datastore_type(String):\n",
      "        The type of data being registered.\n",
      "        \n",
      "         * DATABASE: The data resides in an enterprise database.\n",
      "        \n",
      "         * FOLDER: The data is file-based.\n",
      "        \n",
      "          connection_name(String):\n",
      "        A name for this folder or database that publishers or administrators will\n",
      "        see when they view the server properties.\n",
      "        \n",
      "          server_path(String):\n",
      "        The path or connection to the data as seen by the server.\n",
      "        \n",
      "        If you are registering a DATABASE , this is either the path to a database\n",
      "        connection file (.sde) or a string containing the database connection\n",
      "        parameters.\n",
      "        \n",
      "        If you are registering a FOLDER , this is the path to the folder.\n",
      "        \n",
      "          client_path{String}:\n",
      "        The path or connection to the data as seen by the publisher's machine, if\n",
      "        different from the information used by the server. In some cases the\n",
      "        publisher and the server may be referencing physically distinct databases\n",
      "        or folders. When you provide the publisher path and the server path,\n",
      "        ArcGIS Server automatically corrects the paths at publish time when your\n",
      "        map documents and other resources are transferred to the server.\n",
      "        \n",
      "        If you are registering a DATABASE , provide either the path to a database\n",
      "        connection file (.sde) or a string containing the database connection\n",
      "        parameters.\n",
      "        \n",
      "        If you are registering a FOLDER , provide the path to the folder.\n",
      "        \n",
      "        If you are registering ArcGIS Server's Managed Database, do not provide a\n",
      "        path; instead, provide the string managed for this parameter. ArcGIS\n",
      "        Server's Managed Database is an enterprise geodatabase you designate\n",
      "        where data can be copied at publish time if a user attempts to publish a\n",
      "        feature service from an unregistered data location.\n",
      "        \n",
      "          hostname{String}:\n",
      "        The name of the publisher or client machine that will use this registered\n",
      "        folder or database. If left blank, the name of the machine running the\n",
      "        script will be used.\n",
      "    \n",
      "    AddError(message)\n",
      "        AddError(message)\n",
      "        \n",
      "        Creates a geoprocessing tool error message (Severity=2) that can be\n",
      "        accessed by any of the GetMessages functions.\n",
      "        \n",
      "          message(String):\n",
      "        The message to add.\n",
      "    \n",
      "    AddFieldDelimiters(datasource, field)\n",
      "        AddFieldDelimiters(datasource, field)\n",
      "        \n",
      "        Adds field delimiters to a field name to allow for use in SQL\n",
      "        expressions.\n",
      "        \n",
      "        The field delimiters used in an SQL expression\n",
      "        differ depending on the format of the queried data. For instance,\n",
      "        file geodatabases and shapefiles use double quotation marks (\" \"),\n",
      "        personal geodatabases use square brackets\n",
      "        ([ ]), and enterprise geodatabases don't use field\n",
      "        delimiters. The\n",
      "         function can take away the guess work\n",
      "        in ensuring that the field delimiters used with your SQL expression\n",
      "        are the correct ones.\n",
      "        \n",
      "          datasource(String):\n",
      "        The field delimiters are based on the data source used.\n",
      "        \n",
      "          field(String):\n",
      "        The field name to which delimiters will be added.  The field does not\n",
      "        have to currently exist.\n",
      "    \n",
      "    AddIDMessage(message_type, message_ID, add_argument1=None, add_argument2=None)\n",
      "        AddIDMessage(message_type, message_ID, {add_argument1}, {add_argument2})\n",
      "        \n",
      "        Allows you to use system messages with a script tool.  A list of messages\n",
      "        and IDs that can be used are provided under Understanding geoprocessing\n",
      "        tool errors and warnings .\n",
      "        \n",
      "          message_type(String):\n",
      "        The message type defines whether the message will be an error, warning,\n",
      "        or informative. Valid message types are:\n",
      "        \n",
      "         * ERROR:   Adds an error message to the tool messages.\n",
      "        \n",
      "         * INFORMATIVE: Adds an informative message to the tool messages.\n",
      "        \n",
      "         * WARNING:   Adds a warning message to the tool messages.\n",
      "        \n",
      "          message_ID(Integer):\n",
      "        The message ID allows you to reference existing messages for your\n",
      "        scripting errors and warnings.\n",
      "        \n",
      "          add_argument1{Object}:\n",
      "        Depending on which message ID is used, an argument may be necessary to\n",
      "        complete the message. Common examples include dataset or field names.\n",
      "        Datatype can be string, integer, or double.\n",
      "        \n",
      "          add_argument2{Object}:\n",
      "        Depending on which message ID is used, an argument may be necessary to\n",
      "        complete the message. Common examples include dataset or field names.\n",
      "        Datatype can be string, integer, or double.\n",
      "    \n",
      "    AddMessage(message)\n",
      "        AddMessage(message)\n",
      "        \n",
      "        Creates a geoprocessing informative message (Severity=0) that can be\n",
      "        accessed with any of the GetMessages functions.\n",
      "        \n",
      "          message(String):\n",
      "        The message to add.\n",
      "    \n",
      "    AddReturnMessage(index)\n",
      "        AddReturnMessage(index)\n",
      "        \n",
      "        Sets the return message of a script tool as an output message by index.\n",
      "        \n",
      "          index(Integer):\n",
      "        The message index.\n",
      "    \n",
      "    AddToolbox(input_file, module_name=None)\n",
      "        AddToolbox(input_file, {module_name})\n",
      "        \n",
      "        Imports the specified toolbox into ArcPy, allowing for access to the\n",
      "        toolbox's associated tools.\n",
      "        \n",
      "         Equivalent to the ImportToolbox function.\n",
      "        \n",
      "          input_file(String):\n",
      "        The geoprocessing toolbox added to the ArcPy site package.\n",
      "        \n",
      "          module_name{String}:\n",
      "        If the toolbox does not have an alias, the module_name is required.\n",
      "        \n",
      "        When a tool is accessed through the ArcPy site package, the toolbox alias\n",
      "        where the tool is contained is a required suffix (\n",
      "        arcpy.<toolname>_<alias> ).  Since ArcPy depends on toolbox aliases to\n",
      "        access and execute the correct tool, aliases are extremely important when\n",
      "        importing custom toolboxes.  A good practice is to always define a custom\n",
      "        toolbox's alias;  however, if the toolbox alias is not defined, a\n",
      "        temporary alias can be set as the second parameter.\n",
      "    \n",
      "    AddWarning(message)\n",
      "        AddWarning(message)\n",
      "        \n",
      "        Creates a geoprocessing warning message (Severity=1) that can be accessed\n",
      "        by any of the GetMessages functions.\n",
      "        \n",
      "          message(String):\n",
      "        The message to add.\n",
      "    \n",
      "    AlterAliasName(table, alias)\n",
      "        AlterAliasName(table, alias)\n",
      "        \n",
      "        Updates the alias name for a table or feature class.\n",
      "        \n",
      "          table(String):\n",
      "        Input table or feature class.\n",
      "        \n",
      "          alias(String):\n",
      "        The new alias name.\n",
      "    \n",
      "    AttachLocator(loc_path, fc_path, input_field_names, output_field_names)\n",
      "        AttachLocater(loc_path, fc_path, input_field_names, output_field_names)\n",
      "        \n",
      "            Records the locator used to create the geocode results in the feature class at fc_path.\n",
      "        \n",
      "              loc_path(String):\n",
      "        A string that represents the catalog path to the address locator. Valid\n",
      "        formats for the address locator are locator files ( .loc ) in a file\n",
      "        folder or locators in a geodatabase.\n",
      "        \n",
      "              fc_path(String):\n",
      "            A string representing the catalog path to the feature class created by batch\n",
      "            geocoding with the given locator.\n",
      "        \n",
      "              input_field_names(String)\n",
      "            A string containing a comma-separated list of the input field names.\n",
      "        \n",
      "              output_field_names(String)\n",
      "            A string containing a comma-separated list of the output field names.\n",
      "    \n",
      "    CheckExtension(extension_code)\n",
      "        CheckExtension(extension_code)\n",
      "        \n",
      "        Checks to see if a license is available to be checked out for a specific\n",
      "        type of extension.\n",
      "        \n",
      "        Learn more about licensing and extensions .\n",
      "        \n",
      "          extension_code(String):\n",
      "        Keyword for the extension product that is being checked.\n",
      "        \n",
      "         * 3D:   ArcGIS 3D Analyst extension\n",
      "        \n",
      "         * Datareviewer:   ArcGIS Data Reviewer for Desktop\n",
      "        \n",
      "         * DataInteroperability: ArcGIS Data Interoperability extension for\n",
      "         Desktop\n",
      "        \n",
      "         * Airports: ArcGIS for Aviation: Airports\n",
      "        \n",
      "         * Aeronautical:   ArcGIS for Aviation: Charting\n",
      "        \n",
      "         * Bathymetry: ArcGIS for Maritime: Bathymetry\n",
      "        \n",
      "         * Nautical:   ArcGIS for Maritime: Charting\n",
      "        \n",
      "         * GeoStats:   ArcGIS Geostatistical Analyst extension\n",
      "        \n",
      "         * Network:   ArcGIS Network Analyst extension\n",
      "        \n",
      "         * Spatial:   ArcGIS Spatial Analyst extension\n",
      "        \n",
      "         * Schematics:   ArcGIS Schematics extension\n",
      "        \n",
      "         * Tracking:   ArcGIS Tracking Analyst extension\n",
      "        \n",
      "         * JTX: ArcGIS Workflow Manager for Desktop\n",
      "        \n",
      "         * ArcScan:   ArcScan\n",
      "        \n",
      "         * Business:   Business Analyst\n",
      "        \n",
      "         * Defense:   Esri Defense Solution\n",
      "        \n",
      "         * Foundation:   Esri Production Mapping\n",
      "        \n",
      "         * Highways: Esri Roads and Highways\n",
      "        \n",
      "         * StreetMap:   StreetMap\n",
      "    \n",
      "    CheckInExtension(extension_code)\n",
      "        CheckInExtension(extension_code)\n",
      "        \n",
      "        Returns the license to the License Manager so other applications can use\n",
      "        it.\n",
      "        \n",
      "        Once the extension license has been retrieved by the script, tools using\n",
      "        that extension can be used. Once a script is finished with an extension's\n",
      "        tools, the CheckInExtension function should be used to return the license\n",
      "        to the License Manager so other applications can use it. All checked-out\n",
      "        extension licenses and set product licenses are returned to the License\n",
      "        Manager when a script completes.\n",
      "        \n",
      "          extension_code(String):\n",
      "        Keyword for the extension product that is being checked.\n",
      "        \n",
      "         * 3D:   ArcGIS 3D Analyst extension\n",
      "        \n",
      "         * Datareviewer:   ArcGIS 10.2 Data Reviewer for Desktop\n",
      "        \n",
      "         * DataInteroperability: ArcGIS Data Interoperability extension for\n",
      "         Desktop\n",
      "        \n",
      "         * Airports: ArcGIS for Aviation: Airports\n",
      "        \n",
      "         * Aeronautical:   ArcGIS for Aviation: Charting\n",
      "        \n",
      "         * Bathymetry: ArcGIS for Maritime: Bathymetry\n",
      "        \n",
      "         * Nautical:   ArcGIS for Maritime: Charting\n",
      "        \n",
      "         * GeoStats:   ArcGIS Geostatistical Analyst extension\n",
      "        \n",
      "         * Network:   ArcGIS Network Analyst extension\n",
      "        \n",
      "         * Spatial:   ArcGIS Spatial Analyst extension\n",
      "        \n",
      "         * Schematics:   ArcGIS Schematics extension\n",
      "        \n",
      "         * Tracking:   ArcGIS Tracking Analyst extension\n",
      "        \n",
      "         * JTX: ArcGIS Workflow Manager for Desktop\n",
      "        \n",
      "         * ArcScan:   ArcScan\n",
      "        \n",
      "         * Business:   Business Analyst\n",
      "        \n",
      "         * Defense:   Esri Defense Solution\n",
      "        \n",
      "         * Foundation:   Esri Production Mapping\n",
      "        \n",
      "         * Highways: Esri Roads and Highways\n",
      "        \n",
      "         * StreetMap:   StreetMap   Licensing and extensions\n",
      "    \n",
      "    CheckOutExtension(extension_code)\n",
      "        CheckOutExtension(extension_code)\n",
      "        \n",
      "        Retrieves the license from the License Manager.\n",
      "        \n",
      "        Once the extension license has been retrieved by the script, tools using\n",
      "        that extension can be used. Once a script is finished with an extension's\n",
      "        tools, the CheckInExtension function should be used to return the license\n",
      "        to the License Manager so other applications can use it. All checked-out\n",
      "        extension licenses and set product licenses are returned to the License\n",
      "        Manager when a script completes.\n",
      "        \n",
      "          extension_code(String):\n",
      "        Keyword for the extension product that is being checked.\n",
      "        \n",
      "         * 3D:   ArcGIS 3D Analyst extension\n",
      "        \n",
      "         * Datareviewer:   ArcGIS 10.2 Data Reviewer for Desktop\n",
      "        \n",
      "         * DataInteroperability: ArcGIS Data Interoperability extension for\n",
      "         Desktop\n",
      "        \n",
      "         * Airports: ArcGIS for Aviation: Airports\n",
      "        \n",
      "         * Aeronautical:   ArcGIS for Aviation: Charting\n",
      "        \n",
      "         * Bathymetry: ArcGIS for Maritime: Bathymetry\n",
      "        \n",
      "         * Nautical:   ArcGIS for Maritime: Charting\n",
      "        \n",
      "         * GeoStats:   ArcGIS Geostatistical Analyst extension\n",
      "        \n",
      "         * Network:   ArcGIS Network Analyst extension\n",
      "        \n",
      "         * Spatial:   ArcGIS Spatial Analyst extension\n",
      "        \n",
      "         * Schematics:   ArcGIS Schematics extension\n",
      "        \n",
      "         * Tracking:   ArcGIS Tracking Analyst extension\n",
      "        \n",
      "         * JTX: ArcGIS Workflow Manager for Desktop\n",
      "        \n",
      "         * ArcScan:   ArcScan\n",
      "        \n",
      "         * Business:   Business Analyst\n",
      "        \n",
      "         * Defense:   Esri Defense Solution\n",
      "        \n",
      "         * Foundation:   Esri Production Mapping\n",
      "        \n",
      "         * Highways: Esri Roads and Highways\n",
      "        \n",
      "         * StreetMap:   StreetMap   Licensing and extensions\n",
      "    \n",
      "    CheckProduct(product)\n",
      "        CheckProduct(product)\n",
      "        \n",
      "        Checks to see if the requested license is available.\n",
      "        \n",
      "          product(String):\n",
      "        Product code for the product being checked.\n",
      "        \n",
      "         * arcview:   ArcGIS for Desktop Basic product code\n",
      "        \n",
      "         * arceditor:   ArcGIS for Desktop Standard product code\n",
      "        \n",
      "         * arcinfo:   ArcGIS for Desktop Advanced product code\n",
      "        \n",
      "         * engine:   Engine Runtime product code\n",
      "        \n",
      "         * enginegeodb:   Engine Geodatabase Update product code\n",
      "        \n",
      "         * arcserver:   Server product code\n",
      "    \n",
      "    ClearCredentials(*args, **kwargs)\n",
      "        ClearCredentials(connections).\n",
      "    \n",
      "    ClearEnvironment(environment_name)\n",
      "        ClearEnvironment(environment_name)\n",
      "        \n",
      "        Resets a specific environment setting to its default.\n",
      "        \n",
      "          environment_name(String):\n",
      "        The name of the environment setting that will be reset to its default\n",
      "        setting.\n",
      "    \n",
      "    Command(command_line)\n",
      "        Command(command_line)\n",
      "        \n",
      "        Executes a geoprocessing tool as a single string.\n",
      "        \n",
      "          command_line(String):\n",
      "        The double-quoted string representing a command line command that is to\n",
      "        be executed.\n",
      "    \n",
      "    CopyParameter(from_param, to_param)\n",
      "        CopyParameter(from_param, to_param)\n",
      "        \n",
      "        Copies the specified parameter by index to another parameter in the\n",
      "        script tool. The specified parameters must be of the same data type.\n",
      "        \n",
      "          from_param(Integer):\n",
      "        The index position of the parameter to be copied.\n",
      "        \n",
      "          to_param(Integer):\n",
      "        The index position of the parameter that will be copied to.\n",
      "    \n",
      "    CreateGPSDDraft(result, out_sddraft, service_name, server_type='ARCGIS_SERVER', connection_file_path='', copy_data_to_server=True, folder_name=None, summary=None, tags=None, executionType='Asynchronous', resultMapServer=False, showMessages='None', maximumRecords=1000, minInstances=1, maxInstances=2, maxUsageTime=600, maxWaitTime=60, maxIdleTime=1800, capabilities=None, constantValues=None, choiceLists=None)\n",
      "        CreateGPSDDraft(result, out_sddraft, service_name, {server_type},\n",
      "        {connection_file_path}, {copy_data_to_server}, {folder_name}, {summary},\n",
      "        {tags}, {executionType}, {resultMapServer}, {showMessages},\n",
      "        {maximumRecords}, {minInstances}, {maxInstances}, {maxUsageTime},\n",
      "        {maxWaitTime}, {maxIdleTime}, {capabilities}, {constantValues})\n",
      "        \n",
      "        The function converts Result objects and result files ( .rlt ) into\n",
      "        Service Definition Draft ( .sddraft ) files.\n",
      "        \n",
      "        Service Definition Draft ( .sddraft )  files must be converted into\n",
      "        Service Definition ( .sd ) files before they can be use to publish for\n",
      "        ArcGIS for Server . These functions are not included in ArcGIS Pro at\n",
      "        this time. ArcGIS for Desktop is required to stage and publish.\n",
      "        \n",
      "        A draft service definition does not contain data. A draft service alone\n",
      "        cannot be used to publish a service.\n",
      "        \n",
      "          result(Result):\n",
      "        A reference to one or multiple Result objects or result files ( .rlt ) on\n",
      "        disk. Multiple results must be supplied in a list format. The following\n",
      "        example demonstrates multiple results as input to the CreateGPSDDraft\n",
      "        function.   import arcpy\n",
      "        r1 = arcpy.Buffer_analysis(\"inPts\", \"output.shp\", \"100 Meters\")\n",
      "        r2 = arcpy.GetCount_management(\"FireStations\")\n",
      "        arcpy.CreateGPSDDraft([r1, r2], \"output.sddraft\", \"myservice\")\n",
      "        \n",
      "          out_sddraft(String):\n",
      "        A string that represents the path and file name for the output Service\n",
      "        Definition Draft ( .sddraft ) file.\n",
      "        \n",
      "          service_name(String):\n",
      "        A string that represents the name of the service. This is the name\n",
      "        people will see and use to identify the service. The name can only\n",
      "        contain alphanumeric characters and underscores. No spaces or\n",
      "        special characters are allowed. The name cannot be more than 120\n",
      "        characters in length.\n",
      "        \n",
      "          server_type{String}:\n",
      "        A string representing the server type.\n",
      "        If a connection_file_path parameter is not supplied, then a server_type\n",
      "        must be provided. If a connection_file_path parameter is supplied, then\n",
      "        the server_type is taken from the connection file. In this case, you can\n",
      "        choose FROM_CONNECTION_FILE or skip the parameter entirely.\n",
      "        \n",
      "         * ARCGIS_SERVER:  ArcGIS for Server server type\n",
      "        \n",
      "         * FROM_CONNECTION_FILE: Get the server_type as specified in the\n",
      "         connection_file_path parameter\n",
      "        \n",
      "          connection_file_path{String}:\n",
      "        A string that represents the path and file name to the ArcGIS for Server\n",
      "        connection file  ( .ags ).\n",
      "        \n",
      "          copy_data_to_server{Boolean}:\n",
      "        A Boolean that indicates whether the data referenced in the result will\n",
      "        be copied to the server or not.\n",
      "        The copy_data_to_server parameter is only used if the server_type is\n",
      "        ARCGIS_SERVER and the connection_file_path isn't specified. If the\n",
      "        connection_file_path is specified, then the server's registered data\n",
      "        stores are used. For example, if the data in the result is registered\n",
      "        with the server, then copy_data_to_server will always be False .\n",
      "        Conversely, if the data in the result is not registered with the server,\n",
      "        then copy_data_to_server will always be True .\n",
      "        \n",
      "          folder_name{String}:\n",
      "        A string that represents  a folder name to which you want to publish the\n",
      "        service definition. If the folder does not currently exist, it will be\n",
      "        created.  The default folder is the server root level.\n",
      "        \n",
      "          summary{String}:\n",
      "        A string that represents the Item Description Summary.\n",
      "        \n",
      "        Use this parameter to override the user interface summary, or to provide\n",
      "        a summary if one does not exist. The summary provided here will not be\n",
      "        persisted in the map document.\n",
      "        \n",
      "          tags{String}:\n",
      "        A string that represents the Item Description Tags.\n",
      "        \n",
      "        Use this parameter to override the user interface tags, or to provide\n",
      "        tags if they do not exist. The tags provided here will not be persisted\n",
      "        in the map document.\n",
      "        \n",
      "          executionType{String}:\n",
      "        Asynchronous and synchronous define how the client (the application using\n",
      "        the task) interacts with the server and gets the result from the task.\n",
      "        When a service is set to synchronous, the client waits for the task to\n",
      "        finish. Typically, a synchronous task executes  quickly—five seconds or\n",
      "        less. An asynchronous task typically takes longer to execute, and the\n",
      "        client must periodically ask the server if the task has finished and, if\n",
      "        it has finished, get the result.  A web application using an asynchronous\n",
      "        task must have logic implemented to check the status of a task and handle\n",
      "        the result once execution is finished. ArcGIS Desktop clients handle both\n",
      "        execution types natively.\n",
      "        \n",
      "          resultMapServer{Boolean}:\n",
      "        When publishing a geoprocessing service, you can choose to view the\n",
      "        result of all tasks with the service as a map (in addition to other\n",
      "        results of your task). The map is created on the server using a Map\n",
      "        Service for transport back to the client as an image (a .jpeg , for\n",
      "        example). The symbology, labeling, transparency, and all other properties\n",
      "        of the returned map are the same as the settings of your output layer.\n",
      "        Remember, if you are creating result layers within the Python scripting\n",
      "        environment (outside ArcMap), default symbologies will be used. To\n",
      "        maintain control over symbology you will need to pre-create layer files\n",
      "        with rich symbology and use them to modify the output symbology of your\n",
      "        task.\n",
      "        \n",
      "        When you choose this option, a map service is automatically created\n",
      "        on the server with the same name as your geoprocessing service.\n",
      "        \n",
      "          showMessages{String}:\n",
      "        A string setting the message level for the geoprocessing service. The\n",
      "        following is a list of valid message levels the service will return to\n",
      "        the client.\n",
      "        \n",
      "         * None:  No geoprocessing messages are returned to the client, only\n",
      "         whether\n",
      "        the execution was successful or failed.\n",
      "        \n",
      "         * Error: Only tool messages that produce an error are returned to the\n",
      "        client.\n",
      "        \n",
      "         * Warning:  All tool error and warning messages are returned to the\n",
      "         client.\n",
      "        \n",
      "         * Info:  All tool messages from execution are returned to the client.\n",
      "        \n",
      "          maximumRecords{Integer}:\n",
      "        The maximum number of results the service can return to a client. Setting\n",
      "        this value to a large number means your GIS server can handle sending  a\n",
      "        lot of individual records or features to the client.   If you don't want\n",
      "        to return any features, set this value to 0 (zero).  Typically, you set\n",
      "        this value to zero only when you enable View result with a map service .\n",
      "        \n",
      "          minInstances{Integer}:\n",
      "        An integer value representing the minimum number of instances a service\n",
      "        will start and make available for use. For heavily used services you may\n",
      "        want to increase this value.\n",
      "        \n",
      "          maxInstances{Integer}:\n",
      "        An integer value representing the maximum number of instances a service\n",
      "        can start and make available for use. For heavily used services you may\n",
      "        need to increase this value. Ensure the server has adequate hardware to\n",
      "        support the maximum number of instances you will allow.\n",
      "        \n",
      "          maxUsageTime{Integer}:\n",
      "        The maximum time, in seconds, that a service can be used. You may need to\n",
      "        increase the default of 600 seconds (10 minutes) for long-running\n",
      "        geoprocessing tasks. Alternatively, you may need to reduce this time to\n",
      "        ensure a client will not abuse your services.\n",
      "        \n",
      "          maxWaitTime{Integer}:\n",
      "        The maximum time, in seconds, that a client will wait to connect with an\n",
      "        instance before timing out. When all instances are busy processing\n",
      "        requests, subsequent requests are queued. If this time-out elapses before\n",
      "        an instance becomes available, the task will fail. The default is 60\n",
      "        seconds (1 minute).\n",
      "        \n",
      "          maxIdleTime{Integer}:\n",
      "        The maximum time, in seconds, that an instance will continue to be active\n",
      "        before pool shrinking occurs. Any instances above the minimum number of\n",
      "        instances that have not been used will be shut down once the idle maximum\n",
      "        time value has elapsed.\n",
      "        \n",
      "         capabilities{String}:\n",
      "        Capabilities that a service can support. Currently, only \"UPLOADS\" is\n",
      "        supported.\n",
      "        \n",
      "         constantValues{List}:\n",
      "        List of ToolName.ParameterName which should be set as constant.\n",
      "        \n",
      "         choiceLists{List}:\n",
      "        Specify the supported values for a string parameter.\n",
      "    \n",
      "    CreateGeocodeSDDraft(loc_path, out_sddraft, service_name, server_type='ARCGIS_SERVER', connection_file_path=None, copy_data_to_server=False, folder_name=None, summary=None, tags=None, max_result_size=500, max_batch_size=1000, suggested_batch_size=1000, supported_operations=['GEOCODE', 'REVERSE_GEOCODE'], overwrite_existing_service=False)\n",
      "        CreateGeocodeSDDraft(loc_path, out_sddraft, service_name, {server_type},\n",
      "        {connection_file_path}, {copy_data_to_server}, {folder_name}, {summary},\n",
      "        {tags}, {max_candidates}, {max_batch_size}, {suggested_batch_size},\n",
      "        {supported_operations}, {overwrite_existing_service})\n",
      "        \n",
      "        The function converts  an address locator into a Service Definition Draft\n",
      "        ( .sddraft ) file, which can be used to create a service definition for\n",
      "        publishing a geocode service.\n",
      "        \n",
      "        Service Definition Draft ( .sddraft )  files must be converted into\n",
      "        Service Definition ( .sd ) files before they can be use to publish for\n",
      "        ArcGIS for Server . These functions are not included in ArcGIS Pro at\n",
      "        this time. ArcGIS for Desktop is required to stage and publish.\n",
      "        \n",
      "        A draft service definition does not contain data. A draft service alone\n",
      "        cannot be used to publish a service.\n",
      "        \n",
      "          loc_path(String):\n",
      "        A string that represents the catalog path to the address locator. Valid\n",
      "        formats for the address locator are locator files ( .loc ) in a file\n",
      "        folder or locators in a geodatabase.\n",
      "        \n",
      "          out_sddraft(String):\n",
      "        A string that represents the path and file name for the output Service\n",
      "        Definition Draft ( .sddraft ) file.\n",
      "        \n",
      "          service_name(String):\n",
      "        A string that represents the name of the service. This is the name\n",
      "        people will see and use to identify the service. The name can only\n",
      "        contain alphanumeric characters and underscores. No spaces or\n",
      "        special characters are allowed. The name cannot be more than 120\n",
      "        characters in length.\n",
      "        \n",
      "          server_type{String}:\n",
      "        A string representing the server type.\n",
      "        If a connection_file_path parameter is not supplied, then a server_type\n",
      "        must be provided. If a connection_file_path parameter is supplied, then\n",
      "        the server_type is taken from the connection file. In this case, you can\n",
      "        choose FROM_CONNECTION_FILE or skip the parameter entirely.\n",
      "        \n",
      "         * ARCGIS_SERVER:  ArcGIS for Server server type.\n",
      "        \n",
      "         * FROM_CONNECTION_FILE: Get the server_type as specified in the\n",
      "         connection_file_path parameter.\n",
      "        \n",
      "          connection_file_path{String}:\n",
      "        A string that represents the path and file name to the ArcGIS for Server\n",
      "        connection file  ( .ags ).\n",
      "        \n",
      "          copy_data_to_server{Boolean}:\n",
      "        A Boolean that indicates whether the data referenced in the address\n",
      "        locator will be copied to the server or not.\n",
      "        The copy_data_to_server parameter is only used if the server_type is\n",
      "        ARCGIS_SERVER and the connection_file_path isn't specified. If the\n",
      "        connection_file_path is specified, then the server's registered data\n",
      "        stores are used. For example, if the data in the address locator is\n",
      "        registered with the server, then copy_data_to_server will always be False\n",
      "        . Conversely, if the data in the address locator is not registered with\n",
      "        the server, then copy_data_to_server will always be True .\n",
      "        \n",
      "          folder_name{String}:\n",
      "        A string that represents  a folder name to which you want to publish the\n",
      "        service definition. If the folder does not currently exist, it will be\n",
      "        created when the service definition is published as a service.  The\n",
      "        default folder is the server root level.\n",
      "        \n",
      "          summary{String}:\n",
      "        A string that represents the Item Description Summary.\n",
      "        \n",
      "        Use this parameter to override the user interface summary, or to provide\n",
      "        a summary if one does not exist.\n",
      "        \n",
      "          tags{String}:\n",
      "        A string that represents the Item Description Tags.\n",
      "        \n",
      "        Use this parameter to override the user interface tags, or to provide\n",
      "        tags if they do not exist. To specify multiple tags, separate each tag\n",
      "        with a comma within the string.\n",
      "        \n",
      "          max_candidates{Integer}:\n",
      "        The maximum number of candidates returned by the service when geocoding a\n",
      "        single address.\n",
      "        \n",
      "          max_batch_size{Integer}:\n",
      "        The maximum number of records to be processed in each batch job when\n",
      "        performing batch geocoding.\n",
      "        \n",
      "          suggested_batch_size{Integer}:\n",
      "        The recommended number of records to pass in each batch job when\n",
      "        performing batch geocoding.\n",
      "        \n",
      "          supported_operations{List}:\n",
      "        The built-in operations supported by the service. The parameter should be\n",
      "        specified as a list containing one or more of the following string\n",
      "        keywords: GEOCODE —The service will allow geocoding operations.\n",
      "        REVERSE_GEOCODE —The service will allow  reverse geocoding operations.\n",
      "        SUGGEST —The service will allow suggest operations.\n",
      "        \n",
      "        For example, to specify that the service should only support geocoding\n",
      "        operations and should not allow any reverse geocoding operations, the\n",
      "        parameter should be specified as [\"GEOCODE\"] .\n",
      "            \n",
      "          overwrite_existing_service{Boolean}:\n",
      "        Set this parameter to True if you want the published service to replace\n",
      "        an existing service.\n",
      "    \n",
      "    CreateImageSDDraft(raster_or_mosaic_layer, out_sddraft, service_name, server_type='ARCGIS_SERVER', connection_file_path='', copy_data_to_server=False, folder_name=None, summary=None, tags=None)\n",
      "        CreateImageSDDraft(raster_or_mosaic_layer, out_sddraft, service_name,\n",
      "        {server_type}, {connection_file_path}, {copy_data_to_server},\n",
      "        {folder_name}, {summary}, {tags})\n",
      "        \n",
      "        The CreateImageSDDraft function is the first step to automating the\n",
      "        publishing of a mosaic dataset or raster dataset as an Image Service\n",
      "        using ArcPy. The output created from the CreateImageSDDraft is a Service\n",
      "        Definition Draft ( .sddraft )  file, which is a combination of a mosaic\n",
      "        dataset in the geodatabase or a raster dataset, information about the\n",
      "        server, and a set of service properties. This service definition draft\n",
      "        can be staged as service definition then uploaded to a specified ArcGIS\n",
      "        server as an image service.\n",
      "        \n",
      "        Service Definition Draft ( .sddraft )  files must be converted into\n",
      "        Service Definition ( .sd ) files before they can be use to publish for\n",
      "        ArcGIS for Server . These functions are not included in ArcGIS Pro at\n",
      "        this time. ArcGIS for Desktop is required to stage and publish.\n",
      "        \n",
      "        Information about the server includes the server connection or server\n",
      "        type being published to, the type of service being published, metadata\n",
      "        for the service (Item info), and data references (whether or not data is\n",
      "        being copied to the server).\n",
      "        \n",
      "        A draft service definition does not contain data. A draft service alone\n",
      "        cannot be used to publish a service.\n",
      "        \n",
      "          raster_or_mosaic_layer(String):\n",
      "        The raster layer or mosaic layer that you want to publish.\n",
      "        \n",
      "          out_sddraft(String):\n",
      "        A string that represents the path and file name for the output Service\n",
      "        Definition Draft (.sddraft) file.\n",
      "        \n",
      "          service_name(String):\n",
      "        A string that represents the name of the service. This is the name\n",
      "        people will see and use to identify the service. The name can only\n",
      "        contain alphanumeric characters and underscores. No spaces or\n",
      "        special characters are allowed. The name cannot be more than 120\n",
      "        characters in length.\n",
      "        \n",
      "          server_type{String}:\n",
      "        A string representing the server type.\n",
      "        If a connection_file_path parameter is not supplied, then a server_type\n",
      "        must be provided. If a connection_file_path parameter is supplied, then\n",
      "        the server_type is taken from the connection file. In this case, you can\n",
      "        choose FROM_CONNECTION_FILE or skip the parameter entirely.\n",
      "        \n",
      "         * ARCGIS_SERVER:  ArcGIS for Server server type.\n",
      "        \n",
      "         * FROM_CONNECTION_FILE: Get the server_type as specified in the\n",
      "         connection_file_path parameter.\n",
      "        \n",
      "          connection_file_path{String}:\n",
      "        A string that represents the path and file name to the ArcGIS for Server\n",
      "        connection file  ( .ags ).\n",
      "        \n",
      "          copy_data_to_server{Boolean}:\n",
      "        A Boolean that indicates whether the source data referenced by the mosaic\n",
      "        dataset, the mosaic dataset itself, or the raster dataset published as an\n",
      "        image service will be copied to the server or not.\n",
      "        \n",
      "        The copy_data_to_server parameter is only used if the server_type is\n",
      "        ARCGIS_SERVER and the connection_file_path isn't specified. If the\n",
      "        connection_file_path is specified, then the server's registered data\n",
      "        stores are used. For example, if the workspace that contains the source\n",
      "        data referenced by the mosaic dataset—the mosaic dataset itself or raster\n",
      "        dataset registered with the server—then copy_data_to_server will always\n",
      "        be False . Conversely, if the workspace that contains the source data\n",
      "        referenced by the mosaic dataset—the mosaic dataset or raster dataset is\n",
      "        not registered with the server—then copy_data_to_server will always be\n",
      "        True .\n",
      "        \n",
      "         * False: The data will not be copied to the server. This is the default.\n",
      "        \n",
      "         * True: The data will be copied to the server.\n",
      "        \n",
      "          folder_name{String}:\n",
      "        A string that represents  a folder name to which you want to publish the\n",
      "        service definition. If the folder does not currently exist, it will be\n",
      "        created.  The default folder is the server root level.\n",
      "        \n",
      "          summary{String}:\n",
      "        A string that\n",
      "        represents the Item Description Summary.\n",
      "        \n",
      "        Use this\n",
      "        parameter to override the user interface summary or to provide a\n",
      "        summary if one does not exist.\n",
      "        \n",
      "          tags{String}:\n",
      "        A string that\n",
      "        represents the Item Description Tags.\n",
      "        \n",
      "        Use this\n",
      "        parameter to override the user interface tags or to provide tags\n",
      "        if they do not exist.\n",
      "    \n",
      "    CreateObject(name, options=None)\n",
      "        CreateObject(name, {options})\n",
      "        \n",
      "        Creates geoprocessing objects. The extra arguments can be used to specify\n",
      "        additional requirements for the object creation such as the number of\n",
      "        columns in the ValueTable object.\n",
      "        \n",
      "          name(String):\n",
      "        Name of the object to be created ( ArcSDESQLExecute , Array , Extent ,\n",
      "        FeatureSet , Field , FieldInfo , FieldMap , FieldMappings , Geometry ,\n",
      "        NetCDFFileProperties , Point , RecordSet , Result , SpatialReference ,\n",
      "        ValueTable ).\n",
      "        \n",
      "          options{Object}:\n",
      "        Optional argument(s) depend on the object being created.\n",
      "    \n",
      "    CreateRandomValueGenerator(seed, distribution)\n",
      "        CreateRandomValueGenerator(seed, distribution)\n",
      "        \n",
      "        Creates a new random number generator.\n",
      "        \n",
      "          seed(Integer):\n",
      "        Initializes the random number generator.\n",
      "        \n",
      "          distribution(String):\n",
      "        The random generation algorithm.\n",
      "        \n",
      "         * ACM599:   ACM collected algorithm 599\n",
      "        \n",
      "         * MERSENNE_TWISTER:   Mersenne Twister mt19937\n",
      "        \n",
      "         * STANDARD_C:   Standard C Rand\n",
      "    \n",
      "    CreateScratchName(prefix=None, suffix=None, data_type=None, workspace=None)\n",
      "        CreateScratchName({prefix}, {suffix}, {data_type}, {workspace})\n",
      "        \n",
      "        Creates a unique scratch path name for the specified data type. If no\n",
      "        workspace is given the current workspace is used.\n",
      "        \n",
      "          prefix{String}:\n",
      "        The prefix that is added to the scratchname. By default, a prefix of xx\n",
      "        is used.\n",
      "        \n",
      "          suffix{String}:\n",
      "        The suffix added to the scratchname. This can be an empty double-quoted\n",
      "        string.\n",
      "        \n",
      "          data_type{String}:\n",
      "        The data type which will be used to create the scratchname. Valid\n",
      "        datatypes are:\n",
      "        \n",
      "         * Coverage:   Only valid Coverage names are returned.\n",
      "        \n",
      "         * Dataset:   Only valid Dataset names are returned.\n",
      "        \n",
      "         * FeatureClass:   Only valid FeatureClass names are returned.\n",
      "        \n",
      "         * FeatureDataset:   Only valid FeatureDataset names are returned.\n",
      "        \n",
      "         * Folder:   Only valid Folder names are returned.\n",
      "        \n",
      "         * Geodataset:   Only valid Geodataset names are returned.\n",
      "        \n",
      "         * GeometricNetwork:   Only valid Geometric Network names are returned.\n",
      "        \n",
      "         * ArcInfoTable:   Only valid ArcInfo Table names are returned.\n",
      "        \n",
      "         * NetworkDataset:   Only valid Network Dataset names are returned.\n",
      "        \n",
      "         * RasterBand:   Only valid Raster Band names are returned.\n",
      "        \n",
      "         * RasterCatalog:   Only valid Raster Catalog names are returned.\n",
      "        \n",
      "         * RasterDataset:   Only valid Raster Dataset names are returned.\n",
      "        \n",
      "         * Shapefile:   Only valid Shapefile names are returned.\n",
      "        \n",
      "         * Terrain:   Only valid Terrain names are returned.\n",
      "        \n",
      "         * Workspace:   Only valid Workspace scratchnames are returned.\n",
      "        \n",
      "          workspace{String}:\n",
      "        The workspace used to determine the scratch name to be created. If not\n",
      "        specified, the current workspace is used.\n",
      "    \n",
      "    CreateUniqueName(base_name, workspace=None)\n",
      "        CreateUniqueName(base_name, {workspace})\n",
      "        \n",
      "        Creates a unique name in the specified workspace by appending a number to\n",
      "        the input name. This number is increased until the name is unique. If no\n",
      "        workspace is specified, the current workspace is used.\n",
      "        \n",
      "          base_name(String):\n",
      "        The base name used to create the unique name.\n",
      "        \n",
      "          workspace{String}:\n",
      "        The workspace used for creation of the unique name.\n",
      "    \n",
      "    DecryptPYT(toolbox=None, password=None)\n",
      "        DecryptPYT(toolbox, password)\n",
      "        \n",
      "        Decrypt an encrypted Python toolbox file.\n",
      "        \n",
      "          toolbox{String}:\n",
      "        The encrypted Python toolbox that will be unencrypted.\n",
      "        \n",
      "          password{String}:\n",
      "        The password used to unlock the encrypted Python toolbox.\n",
      "    \n",
      "    Describe(value, data_type=None)\n",
      "        Describe(value, {data_type})\n",
      "        \n",
      "        The Describe function returns a Describe object, with multiple\n",
      "        properties, such as data type, fields, indexes, and many others. Its\n",
      "        properties are dynamic, meaning that depending on what data type is\n",
      "        described, different describe properties will be available for use.\n",
      "        \n",
      "        Describe properties are organized into a series of property groups. Any\n",
      "        particular dataset will acquire the properties of at least one of these\n",
      "        groups. For instance, if describing a geodatabase feature class, you\n",
      "        could access properties from the GDB FeatureClass, FeatureClass, Table,\n",
      "        and Dataset property groups. All data, regardless of the data type, will\n",
      "        always acquire the generic Describe Object properties.\n",
      "        \n",
      "          value(String):\n",
      "        The specified data element or geoprocessing object to describe.\n",
      "        \n",
      "          data_type(String):\n",
      "        The type of data. This is only necessary when naming conflicts exists,\n",
      "        for example, if a geodatabase contains a feature dataset and a feature\n",
      "        class with the same name. In this case, the data type is used to clarify\n",
      "        which dataset you want to describe.\n",
      "    \n",
      "    DisconnectUser(sde_workspace, users=None)\n",
      "        DisconnectUser(sde_workspace, {users})\n",
      "        \n",
      "        Allows an administrator to disconnect users who are currently connected\n",
      "        to an Enterprise geodatabase.\n",
      "        \n",
      "          sde_workspace(String):\n",
      "        The Enterprise geodatabase containing the users to be disconnected.\n",
      "        \n",
      "        The connection properties specified in the Enterprise Geodatabase must\n",
      "        have administrative rights that allow the user to disconnect other\n",
      "        connections.\n",
      "        \n",
      "          users{Integer}:\n",
      "        Specifies which users will be disconnected from the geodatabase.\n",
      "        \n",
      "         * sde_id: The ID value returned from the ListUsers function or the\n",
      "         Connections tab in the Geodatabase Administration dialog. This can be\n",
      "         passed to the function as an individual sde_id or a Python list\n",
      "         containing multiple sde_ids.\n",
      "        \n",
      "         * ALL: Keyword specifying that all connected users should be\n",
      "         disconnected.\n",
      "        \n",
      "        DisconnectUser will not disconnect the user who is executing the\n",
      "        function.\n",
      "    \n",
      "    EncryptPYT(toolbox=None, password=None)\n",
      "        EncryptPYT(toolbox, password)\n",
      "        \n",
      "        Encrypts a Python toolbox file.\n",
      "        \n",
      "          toolbox{String}:\n",
      "        The Python toolbox that will be encrypted in place.\n",
      "        \n",
      "          password{String}:\n",
      "        The password used to lock the encrypted Python toolbox.\n",
      "    \n",
      "    Exists(dataset)\n",
      "        Exists(dataset)\n",
      "        \n",
      "        Determines the existence of the specified data object. Tests for the\n",
      "        existence of feature classes, tables, datasets, shapefiles, workspaces,\n",
      "        layers, and files in the current workspace. The function returns a\n",
      "        Boolean indicating if the element exists.\n",
      "        \n",
      "          dataset(String):\n",
      "        The name, path, or both of a feature class, table, dataset, layer,\n",
      "        shapefile, workspace, or file to be checked for existence.\n",
      "    \n",
      "    FromGeohash(geohash_string)\n",
      "        FromGeohash(geohash_string)\n",
      "        \n",
      "        Converts a geohash string to an Extent object in WGS 1984 coordinates\n",
      "        that represents the corresponding bounding box in the geohash grid.\n",
      "        \n",
      "          geohash_string(String):\n",
      "        The geohash string used to obtain the extent in WGS 1984 coordinates.\n",
      "    \n",
      "    FromWKB(byte_array, spatial_reference=None)\n",
      "        FromWKB(byte_array)\n",
      "        \n",
      "        Create a new Geometry object from a well-known binary (WKB) string stored\n",
      "        in a Python bytearray .\n",
      "        \n",
      "          byte_array(Bytearray):\n",
      "        A WKB string stored in a Python bytearray .\n",
      "    \n",
      "    FromWKT(wkt_string, spatial_reference=None)\n",
      "        FromWKT(wkt_string, {spatial_reference})\n",
      "        \n",
      "        Create a new Geometry object from a well-known text (WKT) string.\n",
      "        \n",
      "          wkt_string(String):\n",
      "        A WKT string.\n",
      "        \n",
      "          spatial_reference{SpatialReference}:\n",
      "        The spatial reference of the geometry. It can be specified with either a\n",
      "        SpatialReference object or string equivalent.\n",
      "    \n",
      "    GetActivePortalURL()\n",
      "        GetActivePortalURL()\n",
      "        \n",
      "        The GetActivePortalURL function returns the URL of the active portal.\n",
      "    \n",
      "    GetArgumentCount()\n",
      "        GetArgumentCount()\n",
      "        \n",
      "        Returns the number of arguments passed to the script.\n",
      "    \n",
      "    GetIDMessage(message_ID, default_message=None)\n",
      "        GetIDMessage(message_ID)\n",
      "        \n",
      "        Get the string of the error or warning ID message.\n",
      "        \n",
      "          message_ID(Integer):\n",
      "        The geoprocessing message ID.\n",
      "    \n",
      "    GetImageEXIFProperties(*args, **kwargs)\n",
      "        GetImageEXIFProperties(in_geotagged_image)\n",
      "        \n",
      "        Extract GPS location coordinates from geotagged image.\n",
      "        \n",
      "          in_geotagged_image(String):\n",
      "        The path to a image file that contains GPS location information, typically in the \n",
      "        EXIF header.\n",
      "    \n",
      "    GetInstallInfo(product=None)\n",
      "        GetInstallInfo()\n",
      "        \n",
      "        The GetInstallInfo function returns a Python dictionary that contains\n",
      "        information on the installation type properties.\n",
      "    \n",
      "    GetLogHistory()\n",
      "        GetLogHistory()\n",
      "        \n",
      "        For script tools and stand-alone scripts , you can determine \n",
      "        whether history logging is active using the GetLogHistory function.\n",
      "    \n",
      "    GetLogMetadata()\n",
      "        GetLogMetadata()\n",
      "        \n",
      "               For script tools and stand-alone scripts, returns True if gp tools\n",
      "               will update the dataset metadata's process lineage log found at \n",
      "               //Esri/DataProperties/lineage/Process\n",
      "        .\n",
      "    \n",
      "    GetMaxSeverity()\n",
      "        GetMaxSeverity()\n",
      "        \n",
      "        Gets the maximum severity returned from the last executed tool.\n",
      "    \n",
      "    GetMessage(index)\n",
      "        GetMessage(index)\n",
      "        \n",
      "        Returns a geoprocessing tool message by its index position.\n",
      "        \n",
      "          index(Integer):\n",
      "        The message to retrieve.\n",
      "    \n",
      "    GetMessageCount()\n",
      "        GetMessageCount()\n",
      "        \n",
      "        Returns a numeric count of all the returned messages from the last\n",
      "        executed command.\n",
      "    \n",
      "    GetMessages(severity=None)\n",
      "        GetMessages({severity})\n",
      "        \n",
      "        Returns the geoprocessing messages from a tool by specified severity\n",
      "        level..\n",
      "        \n",
      "          severity{Integer}:\n",
      "        The severity level of messages to return.\n",
      "        \n",
      "         * 0:   messages returned.\n",
      "        \n",
      "         * 1:   warning messages returned.\n",
      "        \n",
      "         * 2:   error messages returned.\n",
      "        \n",
      "        Not specifying a severity will return all types of messages.\n",
      "    \n",
      "    GetPackageInfo(filename)\n",
      "        GetPackageInfo(filename)\n",
      "        \n",
      "        Return the item infomation for a given package.\n",
      "    \n",
      "    GetParameter(index)\n",
      "        GetParameter(index)\n",
      "        \n",
      "        From the parameter list, select the desired parameter by its index value.\n",
      "        The parameter is returned as an object.\n",
      "        \n",
      "          index(Integer):\n",
      "        Selects the specified parameter, by its index, from the parameter list.\n",
      "    \n",
      "    GetParameterAsText(index)\n",
      "        GetParameterAsText(index)\n",
      "        \n",
      "        Gets the specified parameter as a text string by its index position from\n",
      "        the list of parameters.\n",
      "        \n",
      "          index(Integer):\n",
      "        The numeric position of the parameter in the parameter list.\n",
      "    \n",
      "    GetParameterCount(tool_name)\n",
      "        GetParameterCount(tool_name)\n",
      "        \n",
      "        Returns a count of the parameter values for the specified tool. If the\n",
      "        tool is contained in a custom toolbox, use ImportToolbox to access the\n",
      "        custom tool.\n",
      "        \n",
      "          tool_name(String):\n",
      "        The name of the tool for which the number of parameters will be returned.\n",
      "    \n",
      "    GetParameterInfo(tool_name=None)\n",
      "        GetParameterInfo(tool_name)\n",
      "        \n",
      "        Returns a list of parameter objects for a given tool and is commonly used\n",
      "        in a script tool's ToolValidator class.\n",
      "        \n",
      "          tool_name(String):\n",
      "        The tool name. Including the toolbox alias will help to resolve any\n",
      "        conflicts with duplicate tool names. When the GetParameterInfo function\n",
      "        is used as part of a script tool's ToolValidator class, the tool_name\n",
      "        argument is optional.\n",
      "    \n",
      "    GetParameterValue(tool_name, index)\n",
      "        GetParameterValue(tool_name, index)\n",
      "        \n",
      "        For a specified tool name, returns the default value of the desired\n",
      "        parameter.\n",
      "        \n",
      "          tool_name(String):\n",
      "        The tool name for which the parameter default value will be returned.\n",
      "        \n",
      "          index(Integer):\n",
      "        Index position of the parameter in the specified tool's parameter list.\n",
      "    \n",
      "    GetPortalDescription(portal_URL=None)\n",
      "        GetPortalDescription({portal_URL})\n",
      "        \n",
      "        The GetPortalDescription function returns a dictionary containing\n",
      "        information on the portal.\n",
      "        \n",
      "          portal_URL{String}:\n",
      "        The portal URL.\n",
      "        By default it uses the URL returned by GetActivePortalURL\n",
      "    \n",
      "    GetPortalInfo(portal_URL=None)\n",
      "        GetPortalInfo({portal_URL})\n",
      "        \n",
      "        The GetPortalInfo function returns a dictionary that contains information\n",
      "        on available portals.\n",
      "        \n",
      "          portal_URL{String}:\n",
      "        The portal URL.\n",
      "        By default it uses the URL returned by GetActivePortalURL.\n",
      "    \n",
      "    GetRasterKeyMetadata(*args, **kwargs)\n",
      "        GetRasterKeyMetadata(in_raster, name)\n",
      "        \n",
      "        Get a key metadata value from a raster dataset or mosaic dataset\n",
      "        \n",
      "          in_raster(String):\n",
      "        The path to a raster dataset or mosaic dataset.\n",
      "        \n",
      "          name(String):\n",
      "        Key property name.\n",
      "    \n",
      "    GetReturnCode(index)\n",
      "        GetReturnCode(index)\n",
      "        \n",
      "        Return the message error code by index.\n",
      "        \n",
      "        If the message for the specified index is a warning or informative\n",
      "        message the function will return a 0; if the message is an error the\n",
      "        function will return a value other than 0.\n",
      "        \n",
      "          index(Integer):\n",
      "        The specified position of the message in the returned list of messages,\n",
      "        warnings, or errors.\n",
      "    \n",
      "    GetSeverity(index)\n",
      "        GetSeverity(index)\n",
      "        \n",
      "        Gets the severity code (0, 1, 2) of the specified message by index.\n",
      "        \n",
      "          index(Integer):\n",
      "        Numeric index position of the message in the stack.\n",
      "    \n",
      "    GetSeverityLevel()\n",
      "        GetSeverityLevel()\n",
      "        \n",
      "        Returns the severity level. The severity level is used to control how\n",
      "        geoprocessing tools throw exceptions.\n",
      "    \n",
      "    GetSigninToken()\n",
      "        GetSigninToken()\n",
      "        \n",
      "        Returns token information\n",
      "        when signed in to ArcGIS.com or a local portal.\n",
      "    \n",
      "    GetSystemEnvironment(environment)\n",
      "        GetSystemEnvironment(environment)\n",
      "        \n",
      "        Gets the specified system environment variable value, such as \"TEMP\".\n",
      "        \n",
      "          environment(String):\n",
      "        The name of the system environment variable.\n",
      "    \n",
      "    GetUTMFromLocation(*args, **kwargs)\n",
      "        GetUTMFromLocation(lon, lat)\n",
      "        \n",
      "        Create WGS84 UTM Zone spatial reference from GPS cooridnate in decimal degree.\n",
      "        \n",
      "          lon(Double):\n",
      "        longitude in decimal degree.\n",
      "        \n",
      "          lat(Double):\n",
      "        latitude in decimal degree.\n",
      "    \n",
      "    ImportCredentials(*args, **kwargs)\n",
      "        ImportCredentials(secure_server_connections).\n",
      "    \n",
      "    ImportToolbox(input_file, module_name=None)\n",
      "        ImportToolbox(input_file, {module_name})\n",
      "        \n",
      "        Imports the specified toolbox into ArcPy, allowing for access to the\n",
      "        toolbox's associated tools.\n",
      "        \n",
      "          input_file(String):\n",
      "        The geoprocessing toolbox added to the ArcPy site package.\n",
      "        \n",
      "          module_name{String}:\n",
      "        If the toolbox does not have an alias, the module_name is required.\n",
      "        \n",
      "        When a tool is accessed through the ArcPy site package, the toolbox alias\n",
      "        where the tool is contained is a required suffix (\n",
      "        arcpy.<toolname>_<alias> ).  Since ArcPy depends on toolbox aliases to\n",
      "        access and execute the correct tool, aliases are extremely important when\n",
      "        importing custom toolboxes.  A good practice is to always define a custom\n",
      "        toolbox's alias;  however, if the toolbox alias is not defined, a\n",
      "        temporary alias can be set as the second parameter.\n",
      "    \n",
      "    InsertCursor(dataset, spatial_reference=None)\n",
      "        InsertCursor(dataset, {spatial_reference})\n",
      "        \n",
      "        Inserts rows into a feature class, shapefile, or table. The InsertCursor\n",
      "        returns an enumeration object that hands out row objects.\n",
      "        \n",
      "          dataset(String):\n",
      "        The table, feature class, or shapefile into which rows will be inserted.\n",
      "        \n",
      "          spatial_reference{SpatialReference}:\n",
      "        Coordinates are specified in the spatial_reference provided and converted\n",
      "        on the fly to the coordinate system  of the dataset.\n",
      "    \n",
      "    IsSynchronous(tool_name)\n",
      "        IsSynchronous(tool_name)\n",
      "        \n",
      "        Determines if a tool is running synchronous or asynchronous. When a tool\n",
      "        is synchronous , the results are automatically returned, but no other\n",
      "        action may be taken until the tool has completed. All non-server tools\n",
      "        are synchronous. Server tools may be asynchronous , meaning that once the\n",
      "        tool has been submitted to the server, other functionality can be run\n",
      "        without waiting, and the results must be explicitly requested from the\n",
      "        server.\n",
      "        \n",
      "          tool_name(String):\n",
      "        The name of the tool to determine if it is synchronous.\n",
      "    \n",
      "    ListDataStoreItems(connection_file, datastore_type)\n",
      "        ListDataStoreItems(connection_file, datastore_type)\n",
      "        \n",
      "        Returns a list of the folders or databases registered with an ArcGIS\n",
      "        Server site.\n",
      "        \n",
      "          connection_file(String):\n",
      "        An ArcGIS Server connection file (.ags) for the server whose registered\n",
      "        databases or folders you want to list.\n",
      "        If you've made a connection in the Catalog window of ArcMap, you can use\n",
      "        the connection file found in your user profile directory.\n",
      "        \n",
      "          datastore_type(String):\n",
      "        The type of data that you want to list.\n",
      "        \n",
      "         * DATABASE: Enterprise databases registered with the server will be\n",
      "         listed.\n",
      "        \n",
      "         * FOLDER: File-based data sources registered with the server will be\n",
      "         listed.\n",
      "    \n",
      "    ListDatasets(wild_card=None, feature_type=None)\n",
      "        ListDatasets({wild_card}, {feature_type})\n",
      "        \n",
      "        Lists all of the datasets in a workspace. Search conditions can be\n",
      "        specified for the dataset name and dataset type to limit the list that is\n",
      "        returned.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "        \n",
      "          feature_type{String}:\n",
      "        The feature type to limit the results returned by the wildcard argument.\n",
      "        Valid dataset types are:\n",
      "        \n",
      "         * Coverage: Only coverages.\n",
      "        \n",
      "         * Feature: Coverage or geodatabase dataset, depending on the workspace.\n",
      "        \n",
      "         * GeometricNetwork: Only geometric network datasets.\n",
      "        \n",
      "         * Mosaic: Only mosaic datasets.\n",
      "        \n",
      "         * Network:   Only network datasets.\n",
      "        \n",
      "         * ParcelFabric: Only parcel fabric datasets.\n",
      "        \n",
      "         * Raster:   Only raster datasets.\n",
      "        \n",
      "         * RasterCatalog: Only raster catalog datasets.\n",
      "        \n",
      "         * Schematic: Only schematic datasets.\n",
      "        \n",
      "         * Terrain: Only terrain datasets.\n",
      "        \n",
      "         * Tin:   Only TIN datasets.\n",
      "        \n",
      "         * Topology: Only topology datasets.\n",
      "        \n",
      "         * All:   All datasets in the workspace. This is the default value.\n",
      "    \n",
      "    ListEnvironments(wild_card=None)\n",
      "        ListEnvironments({wild_card})\n",
      "        \n",
      "        The ListEnvironments function returns a list of geoprocessing environment\n",
      "        names.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.   import arcpy\n",
      "        \n",
      "        # A wild_card of \"*workspace\" will return a list including the\n",
      "        #   workspace and scratchWorkspace environment names\n",
      "        arcpy.ListEnvironments(\"*workspace\")\n",
      "    \n",
      "    ListFeatureClasses(wild_card=None, feature_type=None, feature_dataset=None)\n",
      "        ListFeatureClasses({wild_card}, {feature_type}, {feature_dataset})\n",
      "        \n",
      "        Lists the feature classes in the workspace, limited by name, feature\n",
      "        type, and optional feature dataset.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "        \n",
      "          feature_type{String}:\n",
      "        The feature type to limit the results returned by the wild_card argument.\n",
      "        Valid feature types are:\n",
      "        \n",
      "         * Annotation:   Only annotation feature classes are returned.\n",
      "        \n",
      "         * Arc:   Only arc (or line) feature classes are returned.\n",
      "        \n",
      "         * Dimension:   Only dimension feature classes are returned.\n",
      "        \n",
      "         * Edge: Only edge feature classes are returned.\n",
      "        \n",
      "         * Junction: Only junction feature classes are returned.\n",
      "        \n",
      "         * Label:   Only label feature classes are returned.\n",
      "        \n",
      "         * Line:   Only line (or arc) feature classes are returned.\n",
      "        \n",
      "         * Multipatch: Only multipatch feature classes are returned.\n",
      "        \n",
      "         * Node:   Only node feature classes are returned.\n",
      "        \n",
      "         * Point:   Only point feature classes are returned.\n",
      "        \n",
      "         * Polygon:   Only polygon feature classes are returned.\n",
      "        \n",
      "         * Polyline: Only line (or arc) feature classes are returned.\n",
      "        \n",
      "         * Region:   Only region feature classes are returned.\n",
      "        \n",
      "         * Route:   Only route feature classes are returned.\n",
      "        \n",
      "         * Tic:   Only tic feature classes are returned.\n",
      "        \n",
      "         * All:   All datasets in the workspace. This is the default value.\n",
      "        \n",
      "          feature_dataset{String}:\n",
      "        Limits the feature classes returned to the feature dataset, if specified.\n",
      "        If blank, only stand-alone feature classes will be returned in the\n",
      "        workspace.\n",
      "    \n",
      "    ListFields(dataset, wild_card=None, field_type=None)\n",
      "        ListFields(dataset, {wild_card}, {field_type})\n",
      "        \n",
      "        Lists the fields in a feature class, shapefile, or table in a specified\n",
      "        dataset. The returned list can be limited with search criteria for name\n",
      "        and field type and will contain field objects.\n",
      "        \n",
      "          dataset(String):\n",
      "        The specified feature class or table whose fields will be returned.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "        \n",
      "          field_type{String}:\n",
      "        The specified field type to be returned. Valid field types are:\n",
      "        \n",
      "         * All:   All field types are returned. This is the default.\n",
      "        \n",
      "         * BLOB: Only field types of BLOB are returned.\n",
      "        \n",
      "         * Date:   Only field types of Date are returned.\n",
      "        \n",
      "         * Double:   Only field types of Double are returned.\n",
      "        \n",
      "         * Geometry:   Only field types of Geometry are returned.\n",
      "        \n",
      "         * GlobalID: Only field types of GlobalID are returned.\n",
      "        \n",
      "         * GUID:   Only field types of GUID are returned.\n",
      "        \n",
      "         * Integer:   Only field types of Integer are returned.\n",
      "        \n",
      "         * OID:   Only field types of OID are returned.\n",
      "        \n",
      "         * Raster:   Only field types of Raster are returned.\n",
      "        \n",
      "         * Single:   Only field types of Single are returned.\n",
      "        \n",
      "         * SmallInteger:   Only field types of SmallInteger are returned.\n",
      "        \n",
      "         * String:   Only field types of String are returned.\n",
      "    \n",
      "    ListFiles(wild_card=None)\n",
      "        ListFiles({wild_card})\n",
      "        \n",
      "        Returns a list of files in the current workspace based on a query string.\n",
      "        Specifying search conditions can be used to limit the results.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "    \n",
      "    ListIndexes(dataset, wild_card=None)\n",
      "        ListIndexes(dataset, {wild_card})\n",
      "        \n",
      "        Lists the indexes in a feature class, shapefile, or table in a specified\n",
      "        dataset. The list returned can be limited with search criteria for index\n",
      "        name and will contain index objects.\n",
      "        \n",
      "          dataset(String):\n",
      "        The specified feature class or table whose indexes will be returned.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "    \n",
      "    ListInstallations()\n",
      "        ListInstallations()\n",
      "        \n",
      "        The ListInstallations function returns a list of installation types (\n",
      "        server , desktop , engine , arcgispro ).\n",
      "    \n",
      "    ListPortalURLs()\n",
      "        ListPortalURLs()\n",
      "        \n",
      "        The ListPortalURLs function returns a list of available portal URLs.\n",
      "    \n",
      "    ListPrinterNames()\n",
      "        ListPrinterNames()\n",
      "        \n",
      "        Returns a list of available printers on the local computer.\n",
      "    \n",
      "    ListRasters(wild_card=None, raster_type=None)\n",
      "        ListRasters({wild_card}, {raster_type})\n",
      "        \n",
      "        Returns a list of the rasters in the workspace, limited by name and\n",
      "        raster type.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "        \n",
      "          raster_type{String}:\n",
      "        The raster type to limit the results returned by the wild card argument.\n",
      "        Valid raster types are:\n",
      "        \n",
      "         * BMP:   Bitmap graphic raster dataset format.\n",
      "        \n",
      "         * GIF:   Graphic Interchange Format for raster datasets.\n",
      "        \n",
      "         * IMG:   ERDAS IMAGINE raster data format.\n",
      "        \n",
      "         * JP2:   JPEG 2000 raster dataset format.\n",
      "        \n",
      "         * JPG:   Joint Photographics Experts Group raster dataset format.\n",
      "        \n",
      "         * PNG:   Portable Network Graphics raster dataset format.\n",
      "        \n",
      "         * TIF:   Tagged Image File for raster datasets.\n",
      "        \n",
      "         * GRID:   Grid data format.\n",
      "        \n",
      "         * All:   All supported raster types are returned. This is the default.\n",
      "    \n",
      "    ListSpatialReferences(wild_card=None, spatial_reference_type=None)\n",
      "        ListSpatialReferences({wild_card}, {spatial_reference_type})\n",
      "        \n",
      "        Returns a Python list of available spatial reference names for use as an\n",
      "        argument to arcpy.SpatialReference .\n",
      "        \n",
      "          wild_card{String}:\n",
      "        Limit the spatial references listed by a simple wildcard check. The check\n",
      "        is not case sensitive.\n",
      "        \n",
      "        For example, arcpy.ListSpatialReferences(\"*Eckert*\") would list Eckert I\n",
      "        , Eckert II , and so forth.\n",
      "        \n",
      "          spatial_reference_type{String}:\n",
      "        Limit the spatial references listed by type.\n",
      "        \n",
      "         * GCS:   List only Geographic Coordinate Systems.\n",
      "        \n",
      "         * PCS: List only Projected Coordinate Systems.\n",
      "        \n",
      "         * ALL:   List both Projected and Geographic Coordinate Systems. This is\n",
      "         the default.\n",
      "    \n",
      "    ListTables(wild_card=None, table_type=None)\n",
      "        ListTables({wild_card}, {table_type})\n",
      "        \n",
      "        Lists the tables in the workspace, limited by name and table type.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "        \n",
      "          table_type{String}:\n",
      "        The table type to limit the results returned by the wild card argument.\n",
      "        Valid table types are:\n",
      "        \n",
      "         * dBASE:   Only tables of type dBASE are returned.\n",
      "        \n",
      "         * INFO:   Only stand-alone INFO tables are returned.\n",
      "        \n",
      "         * ALL:   All stand-alone tables, including geodatabase tables, are\n",
      "         returned. This is the default.\n",
      "    \n",
      "    ListToolboxes(wild_card=None)\n",
      "        ListToolboxes({wild_card})\n",
      "        \n",
      "        Lists the geoprocessing toolboxes, limited by name.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "    \n",
      "    ListTools(wild_card=None)\n",
      "        ListTools({wild_card})\n",
      "        \n",
      "        Lists the geoprocessing tools, limited by name.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "    \n",
      "    ListTransformations(from_sr, to_sr, extent=None, vertical=False, first_only=False)\n",
      "        ListTransformations(from_sr, to_sr, {extent}, {vertical}, {first_only})\n",
      "        \n",
      "        Returns a list of valid transformation methods for converting data from\n",
      "        one spatial reference to another.  An extent can be used to narrow the\n",
      "        list of valid transformation methods for a specific geographic area.\n",
      "        \n",
      "          from_sr(SpatialReference):\n",
      "        The starting geographic coordinate system. Can be specified with a\n",
      "        SpatialReference object, the name of the spatial reference, or a path to\n",
      "        a projection file (.prj).\n",
      "        \n",
      "          to_sr(SpatialReference):\n",
      "        The final geographic coordinate system.  Can be specified with a\n",
      "        SpatialReference object, the name of the spatial reference, or a path to\n",
      "        a projection file (.prj).\n",
      "        \n",
      "          extent{Extent}:\n",
      "        Only transformations that span the entire extent will be returned.  The\n",
      "        extent needs to be specified in coordinates from the in_sr .  When\n",
      "        working with data, the extent on a Describe object can be used.\n",
      "        \n",
      "          vertical{Boolean}:\n",
      "        This function only returns on type of transformation, either all are \n",
      "        horizontal or all vertical.\n",
      "         - False : horizontal transformations will be returned. This is the\n",
      "         default.\n",
      "         - True : vertical transformations will be returned.\n",
      "        \n",
      "          first_only{Boolean}:\n",
      "        Performance optimization to limit the returned list to single item.\n",
      "         - False : all valid transformations will be returned. This is the\n",
      "         default.\n",
      "         - True : the first valid transformation will be returned.\n",
      "    \n",
      "    ListUsers(sde_workspace)\n",
      "        ListUsers(sde_workspace)\n",
      "        \n",
      "        Returns a list of named tuples containing information for users who are\n",
      "        connected to an enterprise geodatabase.\n",
      "        \n",
      "          sde_workspace(String):\n",
      "        An\n",
      "          enterprise geodatabase (sde connection file).\n",
      "        \n",
      "        The connection properties specified in the enterprise geodatabase must\n",
      "        have administrative rights that allow the user to disconnect other\n",
      "        connections.\n",
      "    \n",
      "    ListVersions(sde_workspace)\n",
      "        ListVersions(sde_workspace)\n",
      "        \n",
      "        Lists the versions the connected user has permission to use.\n",
      "        \n",
      "          sde_workspace(String):\n",
      "        An enterprise geodatabase workspace.\n",
      "    \n",
      "    ListWorkspaces(wild_card=None, workspace_type=None)\n",
      "        ListWorkspaces({wild_card}, {workspace_type})\n",
      "        \n",
      "        Lists all of the workspaces within the set workspace. Search conditions\n",
      "        can be specified for the workspace name and workspace type to limit the\n",
      "        list that is returned.\n",
      "        \n",
      "          wild_card{String}:\n",
      "        The wild_card limits the results returned. If no wild_card is specified,\n",
      "        all values are returned.\n",
      "        \n",
      "          workspace_type{String}:\n",
      "        The workspace type to limit the results returned by the wild card\n",
      "        argument. There are six possible workspace types:\n",
      "        \n",
      "         * Access:   Only personal geodatabases will be selected.\n",
      "        \n",
      "         * Coverage:   Only coverage workspaces will be selected.\n",
      "        \n",
      "         * FileGDB:   Only file geodatabases will be selected.\n",
      "        \n",
      "         * Folder:   Only shapefile workspaces will be selected.\n",
      "        \n",
      "         * SDE:   Only enterprise databases will be selected.\n",
      "        \n",
      "         * All:   All workspaces will be selected. This is the default.\n",
      "    \n",
      "    LogUsageMetering(code, task_name, num_objects=0, units=0.0)\n",
      "        LogUsageMetering(code, task_name, num_objects, units)\n",
      "        \n",
      "        Updates the usage metering for this server tool.\n",
      "    \n",
      "    NumPyArrayToRaster(*args, **kwargs)\n",
      "        NumPyArrayToRaster(in_array, {lower_left_corner}, {x_cell_size},\n",
      "        {y_cell_size}, {value_to_nodata}, {mdinfo})\n",
      "        \n",
      "        Converts a NumPy array to a raster.\n",
      "        \n",
      "          in_array(NumPyArray):\n",
      "        The NumPy array to convert to a raster. A two- or three-dimensional NumPy\n",
      "        array is required.\n",
      "        \n",
      "          lower_left_corner{Point}:\n",
      "        A Point object  defining the lower left corner of the output raster in\n",
      "        map units.\n",
      "        \n",
      "        The default will set the lower left corner to coordinate (0.0, 0.0).\n",
      "        \n",
      "          x_cell_size{Double}:\n",
      "        The cell size in the x direction specified in map units. The input can be\n",
      "        a specified cell size (type: double) value,  or a raster.\n",
      "        \n",
      "        When a dataset is specified, the x cell size of that dataset is used for\n",
      "        the x cell size of  the output raster.\n",
      "        \n",
      "        If only the x_cell_size is identified and not the y_cell_size , a square\n",
      "        cell will result with the specified size.\n",
      "        \n",
      "        If neither x_cell_size nor y_cell_size is specified, a default of 1.0\n",
      "        will be used for both the x and y cell size.\n",
      "        \n",
      "          y_cell_size{Double}:\n",
      "        The cell size in the y direction specified in map units. The input can be\n",
      "        a specified cell size (type: double) value, or a raster.\n",
      "        \n",
      "        When a dataset is specified, the x cell size of that dataset is used for\n",
      "        the y cell size of  the output raster.\n",
      "        \n",
      "        If only the y_cell_size is identified and not the x_cell_size , a square\n",
      "        cell will result with the specified size.\n",
      "        \n",
      "        If neither x_cell_size nor y_cell_size is specified, a default of 1.0\n",
      "        will be used for both the x and y cell size.\n",
      "        \n",
      "          value_to_nodata{Double}:\n",
      "        The value in the NumPy array to assign to NoData in the output raster. If\n",
      "        no value is specified for value_to_nodata , there will not be any NoData\n",
      "        values in the resulting raster.\n",
      "        \n",
      "          mdinfo:\n",
      "        The json or string that defines the multidimensional information\n",
      "    \n",
      "    ParseFieldName(name, workspace=None)\n",
      "        ParseFieldName(name, {workspace})\n",
      "        \n",
      "        Parses a fully qualified field name into its components (database, owner\n",
      "        name, table name, and field name) depending on the workspace.\n",
      "        ParseFieldName returns a string that includes the parsed table name and\n",
      "        contains the database, owner, table, and field names, separated by\n",
      "        commas. The workspace must be a personal, file, or enterprise\n",
      "        geodatabase.\n",
      "        \n",
      "          name(String):\n",
      "        The field name to be parsed.\n",
      "        \n",
      "          workspace{String}:\n",
      "        Specifies the workspace for fully qualifying the field name. The\n",
      "        workspace must be a personal, file, or enterprise geodatabase.\n",
      "    \n",
      "    ParseTableName(name, workspace=None)\n",
      "        ParseTableName(name, {workspace})\n",
      "        \n",
      "        Parses a table name into its components (database, owner, table)\n",
      "        depending on the workspace. ParseTableName returns a string containing\n",
      "        the parsed table name, with the database name, owner name, and table\n",
      "        name, separated by commas. This workspace must be a personal, file, or\n",
      "        enterprise geodatabase.\n",
      "        \n",
      "          name(String):\n",
      "        Specifies which table will be parsed.\n",
      "        \n",
      "          workspace{String}:\n",
      "        Specifies the workspace for fully qualifying the table name. The\n",
      "        workspace must be a personal, file, or enterprise geodatabase.\n",
      "    \n",
      "    ProductInfo()\n",
      "        ProductInfo()\n",
      "        \n",
      "        Returns the current product license.\n",
      "    \n",
      "    RasterToNumPyArray(*args, **kwargs)\n",
      "        RasterToNumPyArray(in_raster, {lower_left_corner}, {ncols}, {nrows},\n",
      "        {nodata_to_value})\n",
      "        \n",
      "        Converts a raster to a NumPy array.\n",
      "        \n",
      "          in_raster(Raster):\n",
      "        The input raster to convert to a NumPy array.\n",
      "        \n",
      "          lower_left_corner{Point}:\n",
      "        The lower left corner within the in_raster from which to  extract the\n",
      "        processing block to  convert to an array.\n",
      "        The x-  and y-values are in map units. If no value is specified, the\n",
      "        origin of the input raster  will be used.\n",
      "        \n",
      "          ncols{Integer}:\n",
      "        The number of columns from the lower_left_corner in the in_raster to\n",
      "        convert to the NumPy array.\n",
      "        \n",
      "        If no  value is specified, the  number of columns of the input raster\n",
      "        will be used.\n",
      "        \n",
      "          nrows{Integer}:\n",
      "        The number of rows from the lower_left_corner in the in_raster to convert\n",
      "        to the NumPy array.\n",
      "        \n",
      "        If no value is specified, the number of rows of the input raster will\n",
      "        used.\n",
      "        \n",
      "          nodata_to_value{Variant}:\n",
      "        The value to assign the in_raster NoData values in the resulting NumPy\n",
      "        array.\n",
      "        \n",
      "        If no value is specified, the NoData value of in_raster will be used.\n",
      "    \n",
      "    RemoveDataStoreItem(connection_file, datastore_type, connection_name)\n",
      "        RemoveDataStoreItem(connection_file, datastore_type, connection_name)\n",
      "        \n",
      "        Unregisters a folder or database from an ArcGIS Server site.\n",
      "        \n",
      "          connection_file(String):\n",
      "        An ArcGIS Server connection file (.ags) for the server whose database or\n",
      "        folder is being unregistered.\n",
      "        If you've made a connection in ArcCatalog, you can use the connection\n",
      "        file found in your user profile directory.\n",
      "        \n",
      "          datastore_type(String):\n",
      "        The type of data being unregistered.\n",
      "        \n",
      "         * DATABASE: The data resides in an enterprise database.\n",
      "        \n",
      "         * FOLDER: The data is file-based.\n",
      "        \n",
      "          connection_name(String):\n",
      "        The name of the folder or database being unregistered, as it is currently\n",
      "        registered with the ArcGIS Server site.\n",
      "    \n",
      "    RemoveToolbox(toolbox)\n",
      "        RemoveToolbox(toolbox)\n",
      "        \n",
      "        Removes the specified toolbox, either by specifying its path or\n",
      "        referencing its alias. Removes the specified toolbox from the current\n",
      "        geoprocessing session. Server toolboxes can also be removed using a\n",
      "        semicolon delimiter.\n",
      "        \n",
      "          toolbox(String):\n",
      "        The name of the toolbox, including either path or alias, to be removed\n",
      "        from the current geoprocessing session. The name/path or alias should be\n",
      "        placed in a double-quoted string.\n",
      "        \n",
      "        Server toolboxes can be removed using a semicolon delimiter.   The name,\n",
      "        including path, or alias, of the toolbox to be removed from the current\n",
      "        geoprocessing session. Place the name/path, or alias, string inside\n",
      "        double quotes. Server toolboxes can also be removed using a semicolon\n",
      "        delimiter.\n",
      "        \n",
      "          Syntax for Internet ArcGIS for Server    URL\n",
      "          servername;{username};{password}    Syntax for Local ArcGIS for Server\n",
      "          machinename;servername .   Syntax for Internet ArcGIS for Server\n",
      "          URL;servername;{username};{password}    Syntax for Local ArcGIS for\n",
      "          Server    machinename;servername\n",
      "    \n",
      "    ResetEnvironments()\n",
      "        ResetEnvironments()\n",
      "        \n",
      "        Resets all environment settings to their default settings.\n",
      "    \n",
      "    ResetProgressor()\n",
      "        ResetProgressor()\n",
      "        \n",
      "        Resets the progressor back to its initial state.\n",
      "    \n",
      "    SearchCursor(dataset, where_clause=None, spatial_reference=None, fields=None, sort_fields=None)\n",
      "        SearchCursor(dataset, {where_clause}, {spatial_reference}, {fields},\n",
      "        {sort_fields})\n",
      "        \n",
      "        The SearchCursor function establishes a read-only cursor on a feature\n",
      "        class or table. The SearchCursor can be used to iterate through row\n",
      "        objects and extract field values. The search can optionally be limited by\n",
      "        a where clause or by field and optionally sorted.\n",
      "        \n",
      "          dataset(String):\n",
      "        The feature class, shapefile, or table containing the rows to be\n",
      "        searched.\n",
      "        \n",
      "          where_clause{String}:\n",
      "        An optional expression that limits the rows returned in the cursor. For\n",
      "        more information on WHERE clauses and SQL statements, see Build an SQL\n",
      "        query .\n",
      "        \n",
      "          spatial_reference{SpatialReference}:\n",
      "        When specified, features will be projected on the fly using the\n",
      "        spatial_reference provided.\n",
      "        \n",
      "          fields{String}:\n",
      "        The fields to be included in the cursor. By default, all fields are\n",
      "        included.\n",
      "        \n",
      "          sort_fields{String}:\n",
      "        Fields used to sort the rows in the cursor. Ascending and descending\n",
      "        order for each field is denoted by A and D.\n",
      "    \n",
      "    SetLogHistory(log_history)\n",
      "        SetLogHistory(log_history)\n",
      "        \n",
      "        For script tools and stand-alone scripts  you can enable or disable \n",
      "        history logging using the SetLogHistory function.\n",
      "        \n",
      "          log_history(Boolean):\n",
      "        True , to enable geoprocessing logging history and False , to disable.\n",
      "    \n",
      "    SetLogMetadata(log_metadata)\n",
      "        SetLogMetadata(log_metadata)\n",
      "        \n",
      "        For script tools and stand-alone scripts  you can enable or disable \n",
      "        if gp tools will update the dataset metadata's process lineage found at \n",
      "        //Esri/DataProperties/lineage/Process\n",
      "        \n",
      "          log_metadata(Boolean):\n",
      "        True, to enable updating of the dataset metadata's process lineage log and False to disable.\n",
      "    \n",
      "    SetParameter(index, value)\n",
      "        SetParameter(index, value)\n",
      "        \n",
      "        Sets a specified parameter property by index using an object. This is\n",
      "        used when passing objects from a script to a script tool. If you need to\n",
      "        pass a text value to a script tool, use SetParameterAsText .\n",
      "        \n",
      "          index(Integer):\n",
      "        The specified parameter's index position in the parameter list.\n",
      "        \n",
      "          value(Object):\n",
      "        The object that will set the specified parameter's property.\n",
      "    \n",
      "    SetParameterAsText(index, text)\n",
      "        SetParameterAsText(index, text)\n",
      "        \n",
      "        Sets a specified parameter property by index using a string value. This\n",
      "        is used when passing values from a script to a script tool. If you need\n",
      "        to pass an object, such as a spatial reference to a script tool, use\n",
      "        SetParameter .\n",
      "        \n",
      "          index(Integer):\n",
      "        The specified parameter's index position in the parameter list.\n",
      "        \n",
      "          text(String):\n",
      "        The string value that will set the specified parameter's property.\n",
      "    \n",
      "    SetParameterSymbology(index, text)\n",
      "        SetParameterSymbology(index, text)\n",
      "        \n",
      "        Sets a parameter's Symbology property.\n",
      "        \n",
      "          index(Integer):\n",
      "        The specified parameter's index position in the parameter list.\n",
      "        \n",
      "          text(String):\n",
      "        The symbology to be applied to the parameter. This can be a \n",
      "        CIM Symbology object or the path to a .lyrx file.\n",
      "    \n",
      "    SetProduct(product)\n",
      "        SetProduct(product)\n",
      "        \n",
      "        The SetProduct function defines the desktop license. SetProduct returns\n",
      "        information on the license.\n",
      "        \n",
      "        The product level should be set by importing the appropriate product\n",
      "        module ( arcinfo , arceditor , arcview , arcserver , arcenginegeodb , or\n",
      "        arcengine ) prior to importing arcpy. The SetProduct function is a legacy\n",
      "        function and cannot set the product once arcpy has been imported.\n",
      "        \n",
      "        For scripts using the arcgisscripting module, the equivalent SetProduct\n",
      "        method is still supported.\n",
      "        \n",
      "          product(String):\n",
      "        Product code for the product being set.\n",
      "        \n",
      "         * arcview:   ArcGIS for Desktop Basic product code\n",
      "        \n",
      "         * arceditor:   ArcGIS for Desktop Standard product code\n",
      "        \n",
      "         * arcinfo:   ArcGIS for Desktop Advanced product code\n",
      "        \n",
      "         * engine:   Engine Runtime product code\n",
      "        \n",
      "         * enginegeodb:   Engine Geodatabase Update product code\n",
      "        \n",
      "         * arcserver:   Server product code\n",
      "    \n",
      "    SetProgressor(type, message=None, min_range=None, max_range=None, step_value=None)\n",
      "        SetProgressor(type, {message}, {min_range}, {max_range}, {step_value})\n",
      "        \n",
      "        Establishes a progressor object which allows progress information to be\n",
      "        passed to a progress dialog box. The appearance of the progress dialog\n",
      "        box can be controlled by choosing either the default progressor or the\n",
      "        step progressor.\n",
      "        \n",
      "          type(String):\n",
      "        The progressor type (default or step).\n",
      "        \n",
      "         * default:   The progressor moves back and forth continuously.\n",
      "        \n",
      "         * step:   The progressor shows the percentage complete.\n",
      "        \n",
      "          message{String}:\n",
      "        The progressor label. The default is no label.\n",
      "        \n",
      "          min_range{Integer}:\n",
      "        Starting value for progressor. Default is 0.\n",
      "        \n",
      "          max_range{Integer}:\n",
      "        Ending value for progressor. Default is 100.\n",
      "        \n",
      "          step_value{Integer}:\n",
      "        The progressor step interval for updating the progress bar.\n",
      "    \n",
      "    SetProgressorLabel(label)\n",
      "        SetProgressorLabel(label)\n",
      "        \n",
      "        Updates the progressor dialog box label.\n",
      "        \n",
      "          label(String):\n",
      "        The label to be used on the progressor dialog box.\n",
      "    \n",
      "    SetProgressorPosition(position=None)\n",
      "        SetProgressorPosition({position})\n",
      "        \n",
      "        Updates the status bar in the progressor dialog box.\n",
      "        \n",
      "          position{Integer}:\n",
      "        Sets the position of the status bar in the progressor dialog box.\n",
      "    \n",
      "    SetRasterKeyMetadata(*args, **kwargs)\n",
      "        SetRasterKeyMetadata(in_raster, name, value)\n",
      "        \n",
      "        Create and set a key property for the input raster dataset or mosaic dataset\n",
      "        \n",
      "          in_raster(String):\n",
      "        The path to a raster dataset or mosaic dataset.\n",
      "        \n",
      "          name(String):\n",
      "        Key property name.\n",
      "        \n",
      "          value(String):\n",
      "        Key property value.\n",
      "    \n",
      "    SetSeverityLevel(severity)\n",
      "        SetSeverityLevel(severity_level)\n",
      "        \n",
      "        Used to control how geoprocessing tools throw exceptions.\n",
      "        \n",
      "          severity_level(Integer):\n",
      "        The severity level\n",
      "        \n",
      "         * 0:   A tool will not throw an exception, even if the tool produces an\n",
      "         error or warning.\n",
      "        \n",
      "         * 1:   If a tool produces a warning or an error, it will throw an\n",
      "         exception.\n",
      "        \n",
      "         * 2:   If a tool produces an error, it will throw an exception. This is\n",
      "         the default.\n",
      "    \n",
      "    SignInToPortal(*args, **kwargs)\n",
      "        SignInToPortal(portal_url, username, password).\n",
      "    \n",
      "    TestSchemaLock(dataset)\n",
      "        TestSchemaLock(dataset)\n",
      "        \n",
      "        Tests if a schema lock can be acquired for a feature class, table, or\n",
      "        feature dataset. Tools that alter schema will require a schema lock to be\n",
      "        placed on the input data. The Add Field tool is an example of such a\n",
      "        tool. If the tool requires a schema lock and is unable to aquire one at\n",
      "        the time of execution, an appropriate error message is returned. Scripts\n",
      "        that use such tools should test if a schema lock can be acquired on the\n",
      "        input data. The TestSchemaLock function will not actually apply a schema\n",
      "        lock on the input data, but will return a Boolean.\n",
      "        \n",
      "          dataset(String):\n",
      "        The input data to be tested if a schema lock can be applied.\n",
      "    \n",
      "    UpdateCursor(dataset, where_clause=None, spatial_reference=None, fields=None, sort_fields=None)\n",
      "        UpdateCursor(dataset, {where_clause}, {spatial_reference}, {fields},\n",
      "        {sort_fields})\n",
      "        \n",
      "        The UpdateCursor function creates a cursor that lets you update or delete\n",
      "        rows on the specified feature class, shapefile, or table. The cursor\n",
      "        places a lock on the data that will remain until either the script\n",
      "        completes or the update cursor object is deleted.\n",
      "        \n",
      "          dataset(String):\n",
      "        The feature class, shapefile, or table containing the rows to be updated\n",
      "        or deleted.\n",
      "        \n",
      "          where_clause{String}:\n",
      "        An optional expression that limits the rows returned in the cursor. For\n",
      "        more information on WHERE clauses and SQL statements, see SQL reference\n",
      "        for elements used in query expressions .\n",
      "        \n",
      "          spatial_reference{SpatialReference}:\n",
      "        Coordinates are specified in the spatial_reference provided and converted\n",
      "        on the fly to the coordinate system  of the dataset.\n",
      "        \n",
      "          fields{String}:\n",
      "        The fields to be included in the cursor. By default, all fields are\n",
      "        included.\n",
      "        \n",
      "          sort_fields{String}:\n",
      "        Fields used to sort the rows in the cursor. Ascending and descending\n",
      "        order for each field is denoted by A and D.\n",
      "    \n",
      "    Usage(tool_name)\n",
      "        Usage(tool_name)\n",
      "        \n",
      "        Returns the syntax for the specified tool or function.\n",
      "        \n",
      "          tool_name(String):\n",
      "        The tool name to display the syntax.\n",
      "    \n",
      "    ValidateDataStoreItem(connection_file, datastore_type, connection_name)\n",
      "        ValidateDataStoreItem(connection_file, datastore_type, connection_name)\n",
      "        \n",
      "        Validates whether a folder or database has been successfully registered\n",
      "        with an ArcGIS Server site.\n",
      "        \n",
      "          connection_file(String):\n",
      "        An ArcGIS Server connection file (.ags) for the server whose registered\n",
      "        database or folder is being validated.\n",
      "        If you've made a connection in ArcCatalog, you can use the connection\n",
      "        file found in your user profile directory.\n",
      "        \n",
      "          datastore_type(String):\n",
      "        The type of data being validated.\n",
      "        \n",
      "         * DATABASE: The data resides in an enterprise database.\n",
      "        \n",
      "         * FOLDER: The data is file-based.\n",
      "        \n",
      "          connection_name(String):\n",
      "        The name by which the folder or database being validated is registered\n",
      "        with the ArcGIS Server site.\n",
      "    \n",
      "    ValidateFieldName(name, workspace=None)\n",
      "        ValidateFieldName(name, {workspace})\n",
      "        \n",
      "        Takes a string (field name) and a workspace path and returns a valid\n",
      "        field name based on name restrictions in the output geodatabase. All\n",
      "        invalid characters in the input string will be replaced with an\n",
      "        underscore (_). The field name restrictions depend on the specific\n",
      "        database used (Structured Query Language [SQL] or Oracle).\n",
      "        \n",
      "          name(String):\n",
      "        The field name to be validated. If the optional workspace is not\n",
      "        specified, the field name is validated against the current workspace.\n",
      "        \n",
      "          workspace{String}:\n",
      "        An optional specified workspace to validate the field name against. The\n",
      "        workspace can be a file system or a personal, file, or enterprise\n",
      "        geodatabase.\n",
      "        \n",
      "        If the workspace is not specified, the field name is validated using the\n",
      "        current workspace environment.  If the workspace environment has not been\n",
      "        set, the field name is validated based on a folder workspace.\n",
      "    \n",
      "    ValidateTableName(name, workspace=None)\n",
      "        ValidateTableName(name, {workspace})\n",
      "        \n",
      "        Takes a table name and a workspace path and returns a valid table name\n",
      "        for the workspace. An underscore \"_\" will replace any invalid character\n",
      "        found in the table name and will honor the name restrictions for the\n",
      "        workspace. The table name restrictions depend on the specific RDBMS used.\n",
      "        \n",
      "          name(String):\n",
      "        The table name to be validated.\n",
      "        \n",
      "          workspace{String}:\n",
      "        The optional workspace against which to validate the table name.\n",
      "        \n",
      "        If the workspace is not specified, the table name is validated using the\n",
      "        current workspace environment.  If the workspace environment has not been\n",
      "        set, the table name is validated based on a folder workspace.\n",
      "\n",
      "DATA\n",
      "    addin_toolbox_path = WindowsPath('C:/Users/admin/AppData/Local/ESRI/Ar...\n",
      "    env = <arcpy.geoprocessing._base.GPEnvironments.<locals>.GPEnvironment...\n",
      "    filename = None\n",
      "    filepath = None\n",
      "    gp = <arcpy.geoprocessing._base.Geoprocessor object>\n",
      "    item = None\n",
      "    modulename = None\n",
      "    msg = 'arcpy expects to run inside a Conda environment,...minal:\\n    ...\n",
      "\n",
      "FILE\n",
      "    d:\\workspace\\arcgis\\pro\\resources\\arcpy\\arcpy\\__init__.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(arcpy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 可以获取具体到某个工具的帮助信息，例如缓冲区分析工具"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function Buffer in module arcpy.analysis:\n",
      "\n",
      "Buffer(in_features=None, out_feature_class=None, buffer_distance_or_field=None, line_side=None, line_end_type=None, dissolve_option=None, dissolve_field=None, method=None)\n",
      "    Buffer_analysis(in_features, out_feature_class, buffer_distance_or_field, {line_side}, {line_end_type}, {dissolve_option}, {dissolve_field;dissolve_field...}, {method})\n",
      "    \n",
      "       Creates buffer polygons around input features to a specified distance.\n",
      "    \n",
      "    INPUTS:\n",
      "     in_features (Feature Layer):\n",
      "         The input point, line, or polygon features to be buffered.\n",
      "     buffer_distance_or_field (Linear Unit / Field):\n",
      "         The distance around the input features that will be buffered.\n",
      "         Distances can be provided as either a value representing a linear\n",
      "         distance or as a field from the input features that contains the\n",
      "         distance to buffer each feature.If linear units are not specified or\n",
      "         are entered as Unknown, the\n",
      "         linear unit of the input features' spatial reference will be used.When\n",
      "         specifying a distance, if the desired linear unit has two words,\n",
      "         such as Decimal Degrees, combine the two words into one (for example,\n",
      "         20 DecimalDegrees).\n",
      "     line_side {String}:\n",
      "         Specifies the sides of the input features that will be buffered. This\n",
      "         parameter is only supported for polygon and line features.\n",
      "    \n",
      "         * FULL-For lines, buffers will be generated on both sides of the line.\n",
      "         For polygons, buffers will be generated around the polygon and will\n",
      "         contain and overlap the area of the input features. This is the\n",
      "         default.\n",
      "    \n",
      "         * LEFT-For lines, buffers will be generated on the topological left of\n",
      "         the line. This option is not supported for polygon input features.\n",
      "    \n",
      "         * RIGHT-For lines, buffers will be generated on the topological right\n",
      "         of the line. This option is not supported for polygon input features.\n",
      "    \n",
      "         * OUTSIDE_ONLY-For polygons, buffers will be generated outside the\n",
      "         input polygon only (the area inside the input polygon will be erased\n",
      "         from the output buffer). This option is not supported for line input\n",
      "         features.\n",
      "         This optional parameter is not available with a Desktop Basic or\n",
      "         Desktop Standard license.\n",
      "     line_end_type {String}:\n",
      "         Specifies the shape of the buffer at the end of line input features.\n",
      "         This parameter is not valid for polygon input features.\n",
      "    \n",
      "         * ROUND-The ends of the buffer will be round, in the shape of a half\n",
      "         circle. This is the default.\n",
      "    \n",
      "         * FLAT-The ends of the buffer will be flat or squared and will end at\n",
      "         the endpoint of the input line feature.\n",
      "         This optional parameter is not available with a Desktop Basic or\n",
      "         Desktop Standard license.\n",
      "     dissolve_option {String}:\n",
      "         Specifies the type of dissolve that will be performed to remove buffer\n",
      "         overlap.\n",
      "    \n",
      "         * NONE-An individual buffer for each feature will be maintained,\n",
      "         regardless of overlap. This is the default.\n",
      "    \n",
      "         * ALL-All buffers will be dissolved together into a single feature,\n",
      "         removing any overlap.\n",
      "    \n",
      "         * LIST-Any buffers sharing attribute values in the listed fields\n",
      "         (carried over from the input features) will be dissolved.\n",
      "     dissolve_field {Field}:\n",
      "         The list of fields from the input features on which the output buffers\n",
      "         will be dissolved. Any buffers sharing attribute values in the listed\n",
      "         fields (carried over from the input features) will be dissolved.\n",
      "     method {String}:\n",
      "         Specifies whether the planar or geodesic method will be used to create\n",
      "         the buffers.\n",
      "    \n",
      "         * PLANAR-If the input features are in a projected coordinate system,\n",
      "         Euclidean buffers will be created. If the input features are in a\n",
      "         geographic coordinate system and the buffer distance is in linear\n",
      "         units (meters, feet, and so forth, as opposed to angular units such as\n",
      "         degrees), geodesic buffers will be created. This is the default. You\n",
      "         can use the Output Coordinate System environment setting to specify\n",
      "         the coordinate system to use. For example, if your input features are\n",
      "         in a projected coordinate system, you can set the environment to a\n",
      "         geographic coordinate system to create geodesic buffers.\n",
      "    \n",
      "         * GEODESIC-All buffers will be created using a shape-preserving\n",
      "         geodesic buffer method, regardless of the input coordinate system.\n",
      "    \n",
      "    OUTPUTS:\n",
      "     out_feature_class (Feature Class):\n",
      "         The feature class containing the output buffers.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(arcpy.Buffer_analysis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 也可以获取具体函数和类的帮助，例如数据查询游标类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class SearchCursor:\n",
      "\n",
      "class SearchCursor(builtins.object)\n",
      " |  SearchCursor(in_table, field_names, where_clause=None, spatial_reference=None, explode_to_points=False, sql_clause=(None, None), datum_transformation=None) -> da.SearchCursor\n",
      " |  \n",
      " |  Create a read-only cursor on a feature class or table.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __enter__(...)\n",
      " |  \n",
      " |  __exit__(...)\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  next(...)\n",
      " |  \n",
      " |  reset(...)\n",
      " |      reset()\n",
      " |      \n",
      " |      Reset iterator to initial state.\n",
      " |      Close all internal objects.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  fields\n",
      " |      fields -> list(string)\n",
      " |      \n",
      " |      Return list of field names)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __esri_toolinfo__ = ['FeatureLayer|Table|TableView|Dataset|FeatureData...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(arcpy.da.SearchCursor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.11 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "06b308fdbfd5979111721ebbf4de1ae2cbf405c7740d4ab5c57cb4c3e518bed6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
